@bolloon/bolloon-agent 0.4.5 → 0.4.7

package/dist/test/bollharness-integration.test.js

@@ -0,0 +1,318 @@
+/**
+ * Bollharness Integration Tests - Standalone Component Tests
+ *
+ * These tests verify the core bollharness integration components
+ * without requiring full constraint-runtime dependency chain.
+ */
+import { describe, it, expect } from 'vitest';
+const GATE_CONFIGS = {
+    0: { entryCondition: '用户提出需求', requiredArtifact: '问题陈述', requiredNextSkill: 'arch', isReviewGate: false },
+    1: { entryCondition: 'Gate 0 产物存在', requiredArtifact: 'ADR草稿', requiredNextSkill: 'arch', isReviewGate: false },
+    2: { entryCondition: 'ADR草稿完成', requiredArtifact: '审查报告', requiredNextSkill: 'review', requiredReviewSubstrate: 'ref-review-sop.md', isReviewGate: true },
+    3: { entryCondition: 'Gate 2 PASS', requiredArtifact: 'PLAN文档', requiredNextSkill: 'harness-eng', isReviewGate: false },
+    4: { entryCondition: 'PLAN vN-final冻结', requiredArtifact: '审查报告', requiredNextSkill: 'review', requiredReviewSubstrate: 'ref-review-sop.md', isReviewGate: true },
+    5: { entryCondition: 'Gate 4 PASS', requiredArtifact: 'WP拆分+TASK.md', requiredNextSkill: 'task-arch', isReviewGate: false },
+    6: { entryCondition: '全部TASK.md完成', requiredArtifact: '审查报告', requiredNextSkill: 'review', requiredReviewSubstrate: 'ref-review-sop.md', isReviewGate: true },
+    7: { entryCondition: 'Gate 6 PASS', requiredArtifact: '代码+LOG.md', requiredNextSkill: 'harness-eng', isReviewGate: false },
+    8: { entryCondition: '全部WP代码+LOG.md存在', requiredArtifact: '审查报告', requiredNextSkill: 'harness-eng-test', requiredReviewSubstrate: 'ref-review-sop.md', isReviewGate: true },
+};
+describe('GateStateMachine', () => {
+    let currentGate = 0;
+    let artifacts = new Map();
+    describe('initialization', () => {
+        it('should start at gate 0', () => {
+            currentGate = 0;
+            expect(currentGate).toBe(0);
+        });
+        it('should have correct gate 0 config', () => {
+            const config = GATE_CONFIGS[0];
+            expect(config.requiredArtifact).toBeDefined();
+            expect(config.isReviewGate).toBe(false);
+        });
+    });
+    describe('gate configs', () => {
+        it('should have 9 gates defined', () => {
+            expect(Object.keys(GATE_CONFIGS).length).toBe(9);
+        });
+        it('should have 4 review gates (2,4,6,8)', () => {
+            expect(GATE_CONFIGS[2].isReviewGate).toBe(true);
+            expect(GATE_CONFIGS[4].isReviewGate).toBe(true);
+            expect(GATE_CONFIGS[6].isReviewGate).toBe(true);
+            expect(GATE_CONFIGS[8].isReviewGate).toBe(true);
+        });
+        it('should have correct next skill for each gate', () => {
+            expect(GATE_CONFIGS[0].requiredNextSkill).toBe('arch');
+            expect(GATE_CONFIGS[5].requiredNextSkill).toBe('task-arch');
+        });
+    });
+    describe('artifacts', () => {
+        it('should be able to submit artifacts', () => {
+            artifacts.set('test', { data: 'test' });
+            expect(artifacts.has('test')).toBe(true);
+        });
+        it('should retrieve submitted artifacts', () => {
+            artifacts.set('adr', { content: 'ADR draft' });
+            const artifact = artifacts.get('adr');
+            expect(artifact).toBeDefined();
+        });
+    });
+});
+// ==================== Guard Router Tests ====================
+const GUARD_MAP = {
+    'src/agents/': ['check_api_types', 'check_skill_parity'],
+    'src/documents/': ['check_doc_freshness', 'check_api_types'],
+    'src/network/': ['check_api_types', 'check_versions'],
+    'docs/': ['check_doc_freshness', 'check_doc_links'],
+    'CLAUDE.md': ['check_doc_freshness', 'check_artifact_link'],
+    'docs/decisions/': ['check_artifact_link', 'check_versions'],
+    'src/test/': ['check_api_types', 'check_versions'],
+};
+function route(filePath) {
+    const matched = [];
+    const sortedPatterns = Object.keys(GUARD_MAP).sort((a, b) => b.length - a.length);
+    for (const pattern of sortedPatterns) {
+        if (filePath.startsWith(pattern) || filePath === pattern.replace(/\/$/, '')) {
+            matched.push(...GUARD_MAP[pattern]);
+        }
+    }
+    return [...new Set(matched)];
+}
+describe('GuardRouter', () => {
+    describe('routing', () => {
+        it('should route agents path to check_api_types', () => {
+            const guards = route('src/agents/pi-sdk.ts');
+            expect(guards).toContain('check_api_types');
+        });
+        it('should route docs path to doc freshness', () => {
+            const guards = route('docs/guide.md');
+            expect(guards).toContain('check_doc_freshness');
+        });
+        it('should route decisions to artifact link check', () => {
+            const guards = route('docs/decisions/adr-001.md');
+            expect(guards).toContain('check_artifact_link');
+        });
+        it('should route test files to version check', () => {
+            const guards = route('src/test/pi-sdk.test.ts');
+            expect(guards).toContain('check_versions');
+        });
+        it('should return empty array for unknown paths', () => {
+            const guards = route('src/unknown/file.ts');
+            expect(guards.length).toBe(0);
+        });
+        it('should handle CLAUDE.md special case', () => {
+            const guards = route('CLAUDE.md');
+            expect(guards).toContain('check_doc_freshness');
+            expect(guards).toContain('check_artifact_link');
+        });
+    });
+    describe('deduplication', () => {
+        it('should deduplicate guard names', () => {
+            const guards = route('src/agents/pi-sdk.ts');
+            const uniqueGuards = [...new Set(guards)];
+            expect(guards.length).toBe(uniqueGuards.length);
+        });
+    });
+});
+// ==================== Context Router Tests ====================
+const CONTEXT_MAP = {
+    'src/agents/': ['agent-architecture', 'multi-agent-patterns'],
+    'src/documents/': ['document-processing', 'parser-patterns'],
+    'src/network/': ['p2p-protocols', 'connection-patterns'],
+    'docs/': ['documentation-standards'],
+    'docs/decisions/': ['decision-tracking', 'adr-patterns'],
+    'src/test/': ['testing-patterns', 'quality-standards'],
+    'CLAUDE.md': ['project-governance', 'truth-source-hierarchy'],
+};
+const FALLBACK_FRAGMENTS = ['general-dev-principles', 'code-quality'];
+function match(filePath) {
+    if (!filePath)
+        return [];
+    const normalized = filePath.replace(/\\/g, '/');
+    const matched = [];
+    const sortedPatterns = Object.keys(CONTEXT_MAP).sort((a, b) => b.length - a.length);
+    for (const pattern of sortedPatterns) {
+        if (normalized.startsWith(pattern) || normalized.endsWith(pattern)) {
+            matched.push(...CONTEXT_MAP[pattern]);
+        }
+    }
+    return [...new Set(matched)];
+}
+describe('ContextRouter', () => {
+    describe('matching', () => {
+        it('should match agents path', () => {
+            const fragments = match('src/agents/protocol.ts');
+            expect(fragments).toContain('agent-architecture');
+            expect(fragments).toContain('multi-agent-patterns');
+        });
+        it('should match docs path', () => {
+            const fragments = match('docs/api.md');
+            expect(fragments).toContain('documentation-standards');
+        });
+        it('should match decisions path', () => {
+            const fragments = match('docs/decisions/adr-001.md');
+            expect(fragments).toContain('decision-tracking');
+            expect(fragments).toContain('adr-patterns');
+        });
+        it('should match CLAUDE.md', () => {
+            const fragments = match('CLAUDE.md');
+            expect(fragments).toContain('project-governance');
+        });
+        it('should return empty for invalid paths', () => {
+            const fragments = match('');
+            expect(fragments.length).toBe(0);
+        });
+    });
+    describe('fallback fragments', () => {
+        it('should have fallback fragments defined', () => {
+            expect(FALLBACK_FRAGMENTS).toContain('general-dev-principles');
+            expect(FALLBACK_FRAGMENTS).toContain('code-quality');
+        });
+    });
+});
+// Mock skills for testing
+const skills = {
+    arch: {
+        name: 'arch',
+        description: 'Project architect. Architecture decisions and boundary freezing.',
+        async execute(params) {
+            const essence = `Core challenge: ${params.task || 'unspecified'}`;
+            const tensions = ['Simplicity vs Flexibility', 'Performance vs Maintainability'];
+            const alternatives = [
+                { name: 'Option A', tradeoffs: ['Fast', 'Limited'], recommendation: 'MVP' },
+                { name: 'Option B', tradeoffs: ['More work', 'Extensible'], recommendation: 'Long-term' }
+            ];
+            return JSON.stringify({ essence, tensions, alternatives }, null, 2);
+        }
+    },
+    lead: {
+        name: 'lead',
+        description: 'Development workflow commander. Fail-closed state machine.',
+        async execute(params) {
+            const action = params.action;
+            if (action === 'get_gate') {
+                return JSON.stringify({ current_gate: 0, gate_name: 'Problem Lock', required_artifact: '问题陈述' }, null, 2);
+            }
+            if (action === 'classify') {
+                const desc = params.description || '';
+                const isPolicy = desc.includes('policy');
+                const isContract = desc.includes('API') || desc.includes('contract');
+                return JSON.stringify({
+                    classification: isPolicy ? 'policy' : isContract ? 'contract' : 'implementation',
+                    fast_track: !isPolicy && !isContract
+                }, null, 2);
+            }
+            return JSON.stringify({ current_gate: 0 });
+        }
+    },
+    task_arch: {
+        name: 'task-arch',
+        description: 'Task decomposition. Breaks down PLAN into work packages.',
+        async execute(params) {
+            const workPackages = [
+                { id: 'WP-1', description: 'Core implementation', files: ['src/agents/*.ts'] },
+                { id: 'WP-2', description: 'Network layer', files: ['src/network/*.ts'] }
+            ];
+            return JSON.stringify({ workPackages }, null, 2);
+        }
+    }
+};
+describe('Skills', () => {
+    describe('arch skill', () => {
+        it('should have correct name and description', () => {
+            expect(skills.arch.name).toBe('arch');
+            expect(skills.arch.description).toContain('architect');
+        });
+        it('should execute and return analysis', async () => {
+            const result = await skills.arch.execute({ task: 'design new feature' });
+            const parsed = JSON.parse(result);
+            expect(parsed.essence).toBeDefined();
+            expect(parsed.tensions).toHaveLength(2);
+            expect(parsed.alternatives).toHaveLength(2);
+        });
+    });
+    describe('lead skill', () => {
+        it('should have correct name', () => {
+            expect(skills.lead.name).toBe('lead');
+        });
+        it('should get gate pack', async () => {
+            const result = await skills.lead.execute({ action: 'get_gate' });
+            const parsed = JSON.parse(result);
+            expect(parsed.current_gate).toBe(0);
+        });
+        it('should classify policy changes', async () => {
+            const result = await skills.lead.execute({ action: 'classify', description: 'change policy boundary' });
+            const parsed = JSON.parse(result);
+            expect(parsed.classification).toBe('policy');
+        });
+        it('should classify contract changes', async () => {
+            const result = await skills.lead.execute({ action: 'classify', description: 'change API contract' });
+            const parsed = JSON.parse(result);
+            expect(parsed.classification).toBe('contract');
+        });
+        it('should classify implementation changes as fast-track eligible', async () => {
+            const result = await skills.lead.execute({ action: 'classify', description: 'fix bug' });
+            const parsed = JSON.parse(result);
+            expect(parsed.classification).toBe('implementation');
+            expect(parsed.fast_track).toBe(true);
+        });
+    });
+    describe('task-arch skill', () => {
+        it('should decompose plan into work packages', async () => {
+            const result = await skills.task_arch.execute({ plan: 'implement feature' });
+            const parsed = JSON.parse(result);
+            expect(parsed.workPackages).toHaveLength(2);
+            expect(parsed.workPackages[0].id).toBe('WP-1');
+        });
+    });
+});
+// ==================== Change Classification Tests ====================
+describe('Change Classification', () => {
+    function classifyChange(description) {
+        const isPolicy = description.includes('policy') || description.includes('boundary');
+        const isContract = description.includes('API') || description.includes('contract') || description.includes('schema');
+        const isImplementation = !isPolicy && !isContract;
+        return {
+            classification: isPolicy ? 'policy' : isContract ? 'contract' : 'implementation',
+            fast_track: isImplementation
+        };
+    }
+    it('should classify policy changes', () => {
+        const result = classifyChange('change policy boundary');
+        expect(result.classification).toBe('policy');
+        expect(result.fast_track).toBe(false);
+    });
+    it('should classify contract changes', () => {
+        const result = classifyChange('change API contract');
+        expect(result.classification).toBe('contract');
+        expect(result.fast_track).toBe(false);
+    });
+    it('should classify implementation changes', () => {
+        const result = classifyChange('fix bug in code');
+        expect(result.classification).toBe('implementation');
+        expect(result.fast_track).toBe(true);
+    });
+    it('should classify schema changes as contract', () => {
+        const result = classifyChange('update database schema');
+        expect(result.classification).toBe('contract');
+    });
+});
+// ==================== Integration Configuration Tests ====================
+describe('BollharnessConfig', () => {
+    function createDefaultConfig() {
+        return {
+            enabled: true,
+            guardsEnabled: true,
+            contextEnabled: true,
+            skillsEnabled: true,
+            gatesEnabled: true,
+        };
+    }
+    it('should have default config with all features enabled', () => {
+        const config = createDefaultConfig();
+        expect(config.enabled).toBe(true);
+        expect(config.guardsEnabled).toBe(true);
+        expect(config.contextEnabled).toBe(true);
+        expect(config.skillsEnabled).toBe(true);
+        expect(config.gatesEnabled).toBe(true);
+    });
+});

package/dist/test/channel-agent-multi-dialogue.js

@@ -0,0 +1,205 @@
+/**
+ * Channel Agent Multi-Turn Dialogue Test
+ *
+ * 测试场景：
+ * 1. 两个 Channel Agent (Alice/Bob) 之间的多轮对话
+ * 2. 基于判断力的 Harness 调用 (Gate 1-8)
+ * 3. 上下文感知的 Gate 选择
+ * 4. Persona 设计能力
+ *
+ * 运行: npx tsx src/test/channel-agent-multi-dialogue.ts
+ */
+import { config } from 'dotenv';
+import { createChannelAgent, ChannelAgentRegistry } from '../social/channels/channel-agent-session.js';
+config();
+const PORT_ALICE = 8001;
+const PORT_BOB = 8002;
+async function testMultiTurnDialogue() {
+    console.log('\n========================================');
+    console.log('  Channel Agent 多轮对话测试');
+    console.log('  场景: 完成一个用户认证系统的需求讨论');
+    console.log('========================================\n');
+    // 创建 Agent 注册表
+    const registry = new ChannelAgentRegistry();
+    // 创建 Alice
+    const alice = createChannelAgent({
+        name: 'Alice',
+        port: PORT_ALICE,
+        domain: '架构',
+        capabilities: ['架构设计', '代码审查', '任务分解']
+    });
+    // 创建 Bob
+    const bob = createChannelAgent({
+        name: 'Bob',
+        port: PORT_BOB,
+        domain: '开发',
+        capabilities: ['代码编写', '调试', '测试']
+    });
+    // 注册
+    registry.register(alice);
+    registry.register(bob);
+    // 设计 persona
+    alice.designPersona({
+        name: 'Alice',
+        type: 'developer',
+        domain: '架构',
+        tone: 'professional'
+    });
+    bob.designPersona({
+        name: 'Bob',
+        type: 'developer',
+        domain: '开发',
+        tone: 'technical'
+    });
+    // 启动
+    await alice.start();
+    await bob.start();
+    // 对话脚本
+    const script = [
+        // 第1轮 - 架构讨论
+        { from: 'Alice', to: 'Bob', content: 'Bob，我们需要设计一个新的用户认证系统。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '好的，具体需要哪些功能？', expectHarness: false },
+        // 第2轮 - 需求讨论
+        { from: 'Alice', to: 'Bob', content: '需要登录、注册、找回密码，还要支持社交登录。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '明白了。这个系统需要什么级别的安全性？', expectHarness: false },
+        // 第3轮 - 安全讨论 → Gate 4
+        { from: 'Alice', to: 'Bob', content: '需要处理金融数据，所以安全性很重要。请检查一下架构设计。', expectHarness: true, expectGate: 4 },
+        { from: 'Bob', to: 'Alice', content: '好的，我来分析一下架构设计，看看有没有安全风险。', expectHarness: true, expectGate: 1 },
+        // 第4轮 - 代码审查 → Gate 2
+        { from: 'Alice', to: 'Bob', content: '架构看起来不错。帮我 review 一下登录模块的实现。', expectHarness: true, expectGate: 2 },
+        { from: 'Bob', to: 'Alice', content: '好的，让我检查登录模块的代码实现。', expectHarness: true, expectGate: 2 },
+        // 第5轮 - 优化讨论
+        { from: 'Alice', to: 'Bob', content: '代码审查发现了一些问题，需要优化错误处理。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '同意，错误处理需要改进。', expectHarness: false },
+        // 第6轮 - 任务分解 → Gate 5
+        { from: 'Alice', to: 'Bob', content: '好的，现在我们来分解任务，制定开发计划。', expectHarness: true, expectGate: 5 },
+        { from: 'Bob', to: 'Alice', content: '我来帮你把任务分解成可执行的小块。', expectHarness: true, expectGate: 5 },
+        // 第7轮 - 开始实现
+        { from: 'Alice', to: 'Bob', content: '任务分解得很好。我们开始实现第一个任务吧。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '好的，开始实现登录模块。', expectHarness: false },
+        // 第8轮 - 代码实现 → Gate 7
+        { from: 'Alice', to: 'Bob', content: '实现完成，帮我优化一下代码质量。', expectHarness: true, expectGate: 7 },
+        { from: 'Bob', to: 'Alice', content: '好的，我来进行代码优化。', expectHarness: true, expectGate: 7 },
+        // 第9轮 - 测试验证 → Gate 8
+        { from: 'Alice', to: 'Bob', content: '代码优化完成，帮我验证一下质量。', expectHarness: true, expectGate: 8 },
+        { from: 'Bob', to: 'Alice', content: '好的，我来运行测试验证。', expectHarness: true, expectGate: 8 },
+        // 第10轮 - 完成
+        { from: 'Alice', to: 'Bob', content: '测试通过了！继续下一个任务。', expectHarness: false },
+        { from: 'Bob', to: 'Alice', content: '太好了！继续加油。', expectHarness: false },
+    ];
+    console.log('━━━ 开始多轮对话 ━━━\n');
+    let harnessCallCount = 0;
+    const gateStats = new Map();
+    for (let i = 0; i < script.length; i++) {
+        const { from, to, content, expectHarness, expectGate } = script[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}/receive`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ fromName: from, content })
+            });
+            const result = await resp.json();
+            console.log(`\n[${to}] 处理结果:`);
+            if (result.harnessCalled) {
+                console.log(`   🧠 调用 Harness: Gate ${result.gate}`);
+                console.log(`   📋 Skills: ${result.skills?.join(', ') || '无'}`);
+                harnessCallCount++;
+                gateStats.set(result.gate, (gateStats.get(result.gate) || 0) + 1);
+                if (expectHarness && result.gate !== expectGate) {
+                    console.log(`   ⚠️ 期望 Gate ${expectGate}，实际 ${result.gate}`);
+                }
+            }
+            else {
+                console.log(`   🧠 普通对话 (无需 Harness)`);
+            }
+            console.log(`   📤 回复: ${result.response?.substring(0, 80)}...`);
+            // 等待一下再继续
+            await new Promise(r => setTimeout(r, 300));
+        }
+        catch (err) {
+            console.log(`   ❌ 发送失败:`, err);
+        }
+        console.log('');
+    }
+    // 结果汇总
+    console.log('━━━ 结果汇总 ━━━\n');
+    console.log(`[Alice] 对话数: ${alice.getDialogHistory().length}`);
+    console.log(`[Bob] 对话数: ${bob.getDialogHistory().length}`);
+    console.log(`\nHarness 调用次数: ${harnessCallCount}`);
+    console.log('\nGate 统计:');
+    for (const [gate, count] of Array.from(gateStats.entries()).sort((a, b) => a[0] - b[0])) {
+        const gateNames = {
+            1: '架构设计',
+            2: '代码审查',
+            4: '安全检查',
+            5: '任务分解',
+            7: '代码实现',
+            8: '测试验证'
+        };
+        console.log(`  Gate ${gate} (${gateNames[gate] || '未知'}): ${count} 次`);
+    }
+    // 健康检查
+    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] DID: ${aliceHealth.id.substring(0, 16)}...`);
+    console.log(`[Bob]   DID: ${bobHealth.id.substring(0, 16)}...`);
+    console.log(`\n对话总数: ${aliceHealth.dialogCount + bobHealth.dialogCount}`);
+    console.log(`Harness 调用: ${harnessCallCount} 次`);
+    const success = harnessCallCount >= 6;
+    console.log(`\n${success ? '✅' : '⚠️'} ${success ? '测试成功' : '测试部分成功'}`);
+    // 清理
+    registry.clear();
+    console.log('\n========================================\n');
+    return success;
+}
+async function testPersonaDesign() {
+    console.log('\n========================================');
+    console.log('  Persona 设计测试');
+    console.log('========================================\n');
+    const agent = createChannelAgent({
+        name: 'TestAgent',
+        port: 8010,
+        domain: '通用'
+    });
+    await agent.start();
+    // 设计不同类型的 persona
+    const personaTypes = [
+        { name: 'ArchMaster', type: 'developer', domain: '架构', tone: 'professional' },
+        { name: 'CodeReviewer', type: 'reviewer', domain: '安全', tone: 'formal' },
+        { name: 'TaskManager', type: 'manager', domain: '项目管理', tone: 'professional' },
+        { name: 'CreativeDesigner', type: 'designer', domain: '设计', tone: 'casual' }
+    ];
+    console.log('━━━ 设计 Persona ━━━\n');
+    for (const request of personaTypes) {
+        const persona = agent.designPersona(request);
+        console.log(`设计 ${request.type} persona:`);
+        console.log(`  名称: ${persona.name}`);
+        console.log(`  描述: ${persona.description}`);
+        console.log(`  性格: ${persona.personality}`);
+        console.log(`  能力: ${persona.capabilities.join(', ')}`);
+        console.log(`  兴趣: ${persona.interests.join(', ')}`);
+        console.log('');
+    }
+    // 获取当前 persona
+    const currentPersona = agent.getPersona();
+    console.log('当前 Persona:');
+    console.log(JSON.stringify(currentPersona, null, 2));
+    agent.shutdown();
+    console.log('\n========================================\n');
+}
+async function main() {
+    try {
+        await testMultiTurnDialogue();
+        await testPersonaDesign();
+        process.exit(0);
+    }
+    catch (err) {
+        console.error('测试失败:', err);
+        process.exit(1);
+    }
+}
+main();