@bolloon/bolloon-agent 0.2.8 → 0.2.10

package/dist/test/judgment-decision.test.js

@@ -0,0 +1,219 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { evaluateDecision, submitDecisionResponse, queryInternalAgents, getPendingDecisions, getDecisionRequest, getDecisionStats, setConfidenceThreshold, setDefaultDecisionLevel, } from '../pi-ecosystem-judgment/decision.js';
+import * as judgmentModule from '../pi-ecosystem-judgment/index.js';
+vi.mock('../pi-ecosystem-colony/index.js', () => ({
+    listAnts: vi.fn().mockReturnValue([
+        { id: 'ant-1', name: 'BuilderAnt', signal: 'ACTIVE', capabilities: ['coding'] },
+        { id: 'ant-2', name: 'ReviewerAnt', signal: 'ACTIVE', capabilities: ['review'] },
+        { id: 'ant-3', name: 'TesterAnt', signal: 'ACTIVE', capabilities: ['testing'] },
+    ]),
+}));
+vi.mock('../pi-ecosystem-subagents/index.js', () => ({
+    listSubagents: vi.fn().mockReturnValue([
+        { id: 'sub-1', name: 'CodeSubagent', status: 'running', capabilities: ['coding'] },
+        { id: 'sub-2', name: 'DocSubagent', status: 'running', capabilities: ['writing'] },
+    ]),
+}));
+describe('Decision System - Internal vs External Judgment Communication', () => {
+    beforeEach(() => {
+        setConfidenceThreshold(0.7);
+        setDefaultDecisionLevel('autonomous');
+        vi.clearAllMocks();
+    });
+    describe('Decision Level Determination', () => {
+        it('should be autonomous when confidence >= threshold', async () => {
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.9);
+            const request = await evaluateDecision('Use const instead of var', 'typescript', 'agent-001', 0.7);
+            expect(request.level).toBe('autonomous');
+            expect(request.targets).toEqual([]);
+            expect(request.status).toBe('pending');
+        });
+        it('should consult_internal when confidence >= threshold * 0.7 but < threshold', async () => {
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.5);
+            const request = await evaluateDecision('Refactor this function', 'refactor', 'agent-001', 0.7);
+            expect(request.level).toBe('consult_internal');
+            expect(request.targets).toContain('colony_ant');
+            expect(request.targets).toContain('subagent');
+            expect(request.targets).not.toContain('p2p_agent');
+            expect(request.targets).not.toContain('human');
+        });
+        it('should consult_external when confidence >= threshold * 0.4 but < threshold * 0.7', async () => {
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.35);
+            const request = await evaluateDecision('Cross-system migration strategy', 'migration', 'agent-001', 0.7);
+            expect(request.level).toBe('consult_external');
+            expect(request.targets).toContain('p2p_agent');
+            expect(request.targets).toContain('colony_ant');
+            expect(request.targets).toContain('subagent');
+        });
+        it('should require_human when confidence < threshold * 0.4', async () => {
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.2);
+            const request = await evaluateDecision('Strategic pivot decision', 'strategy', 'agent-001', 0.7);
+            expect(request.level).toBe('require_human');
+            expect(request.targets).toEqual(['human']);
+        });
+        it('should default to confidence 0.5 when no judgments exist', async () => {
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.5);
+            const request = await evaluateDecision('No prior judgment context', 'unknown', 'agent-001', 0.7);
+            expect(request.confidence).toBe(0.5);
+            expect(request.level).toBe('consult_internal');
+            expect(request.targets).toContain('colony_ant');
+        });
+    });
+    describe('Internal Consultation (colony_ant, subagent)', () => {
+        it('should query up to 3 colony ants for consult_internal', async () => {
+            const request = await evaluateDecision('Which approach is better: A or B?', 'decision', 'agent-001', 0.7);
+            request.level = 'consult_internal';
+            request.targets = ['colony_ant', 'subagent'];
+            const results = await queryInternalAgents(request);
+            expect(results.length).toBeGreaterThan(0);
+            expect(results.some(r => r.target === 'colony_ant')).toBe(true);
+        });
+        it('should query up to 2 subagents for consult_internal', async () => {
+            const request = await evaluateDecision('Code review decision', 'review', 'agent-001', 0.7);
+            request.level = 'consult_internal';
+            request.targets = ['colony_ant', 'subagent'];
+            const results = await queryInternalAgents(request);
+            expect(results.some(r => r.target === 'subagent')).toBe(true);
+        });
+        it('should include consultation results in request', async () => {
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.5);
+            const request = await evaluateDecision('Implementation strategy', 'strategy', 'agent-001', 0.7);
+            expect(request.targets.length).toBeGreaterThan(0);
+        });
+    });
+    describe('External Consultation (p2p_agent)', () => {
+        it('should include p2p_agent in consult_external targets', async () => {
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.35);
+            const request = await evaluateDecision('Peer system integration decision', 'integration', 'agent-001', 0.7);
+            expect(request.level).toBe('consult_external');
+            expect(request.targets).toContain('p2p_agent');
+        });
+        it('should support external peer-to-peer consultation', async () => {
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.35);
+            const request = await evaluateDecision('Protocol version negotiation', 'protocol', 'agent-001', 0.7);
+            expect(request.targets).toContain('p2p_agent');
+            expect(request.targets).toContain('colony_ant');
+            expect(request.targets).toContain('subagent');
+        });
+    });
+    describe('Decision Response Flow', () => {
+        it('should update status to authorized on positive response', async () => {
+            const request = await evaluateDecision('Proceed with deployment', 'deploy', 'agent-001', 0.7);
+            const response = await submitDecisionResponse(request.id, {
+                authorized: true,
+                content: 'Approved',
+                by: 'human',
+                timestamp: new Date().toISOString(),
+            });
+            expect(response?.status).toBe('authorized');
+            expect(response?.respondedAt).toBeDefined();
+        });
+        it('should update status to rejected on negative response', async () => {
+            const request = await evaluateDecision('Skip tests for faster delivery', 'testing', 'agent-001', 0.7);
+            const response = await submitDecisionResponse(request.id, {
+                authorized: false,
+                content: 'No, tests are required',
+                by: 'human',
+                timestamp: new Date().toISOString(),
+            });
+            expect(response?.status).toBe('rejected');
+        });
+        it('should support delegation to other targets', async () => {
+            const request = await evaluateDecision('Architecture decision', 'architecture', 'agent-001', 0.7);
+            const response = await submitDecisionResponse(request.id, {
+                authorized: true,
+                content: 'Delegating to senior architect',
+                delegate: 'colony_ant',
+                by: 'human',
+                timestamp: new Date().toISOString(),
+            });
+            expect(response?.response?.delegate).toBe('colony_ant');
+        });
+    });
+    describe('Decision State Tracking', () => {
+        it('should track pending decisions', async () => {
+            await evaluateDecision('Decision 1', 'context', 'agent-001', 0.7);
+            await evaluateDecision('Decision 2', 'context', 'agent-001', 0.7);
+            const pending = getPendingDecisions();
+            expect(pending.length).toBeGreaterThanOrEqual(2);
+        });
+        it('should retrieve decision by ID', async () => {
+            const created = await evaluateDecision('Test Decision', 'context', 'agent-001', 0.7);
+            const retrieved = getDecisionRequest(created.id);
+            expect(retrieved).toBeDefined();
+            expect(retrieved?.description).toBe('Test Decision');
+        });
+        it('should calculate decision statistics', async () => {
+            await evaluateDecision('Decision A', 'context', 'agent-001', 0.7);
+            await evaluateDecision('Decision B', 'context', 'agent-001', 0.7);
+            const stats = getDecisionStats();
+            expect(stats.total).toBeGreaterThanOrEqual(2);
+            expect(stats.pending).toBeGreaterThanOrEqual(2);
+        });
+    });
+    describe('Threshold Sensitivity', () => {
+        it('should escalate to require_human with very high threshold', async () => {
+            setConfidenceThreshold(0.9);
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.3);
+            const request = await evaluateDecision('Conservative decision', 'context', 'agent-001');
+            expect(request.level).toBe('require_human');
+            expect(request.targets).toEqual(['human']);
+        });
+        it('should be autonomous with low threshold', async () => {
+            setConfidenceThreshold(0.3);
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.5);
+            const request = await evaluateDecision('Aggressive decision', 'context', 'agent-001');
+            expect(request.level).toBe('autonomous');
+            expect(request.targets).toEqual([]);
+        });
+    });
+    describe('Cross-Cutting Concerns', () => {
+        it('should create unique decision IDs', async () => {
+            const request1 = await evaluateDecision('Decision 1', 'c', 'a', 0.7);
+            const request2 = await evaluateDecision('Decision 2', 'c', 'a', 0.7);
+            expect(request1.id).not.toBe(request2.id);
+        });
+        it('should include agent ID in request', async () => {
+            const request = await evaluateDecision('Test', 'c', 'my-agent-123', 0.7);
+            expect(request.agentId).toBe('my-agent-123');
+        });
+        it('should record creation timestamp', async () => {
+            const before = new Date().toISOString();
+            const request = await evaluateDecision('Test', 'c', 'a', 0.7);
+            const after = new Date().toISOString();
+            expect(request.createdAt).toBeDefined();
+            expect(request.createdAt >= before).toBe(true);
+            expect(request.createdAt <= after).toBe(true);
+        });
+    });
+});
+describe('Decision Level Boundary Conditions', () => {
+    beforeEach(() => {
+        setConfidenceThreshold(0.7);
+    });
+    it.each([
+        { confidence: 0.9, expectedLevel: 'autonomous' },
+        { confidence: 0.5, expectedLevel: 'consult_internal' },
+        { confidence: 0.35, expectedLevel: 'consult_external' },
+        { confidence: 0.2, expectedLevel: 'require_human' },
+    ])('confidence $confidence should map to $expectedLevel', async ({ confidence, expectedLevel }) => {
+        vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(confidence);
+        const request = await evaluateDecision('Boundary test', 'boundary', 'agent-001', 0.7);
+        expect(request.level).toBe(expectedLevel);
+    });
+});
+describe('Consultation Target Matrix', () => {
+    beforeEach(() => {
+        setConfidenceThreshold(0.7);
+    });
+    const matrix = [
+        { level: 'autonomous', expectedTargets: [] },
+        { level: 'consult_internal', expectedTargets: ['colony_ant', 'subagent'] },
+        { level: 'consult_external', expectedTargets: ['colony_ant', 'subagent', 'p2p_agent'] },
+        { level: 'require_human', expectedTargets: ['human'] },
+    ];
+    it.each(matrix)('level $level should have targets $expectedTargets', ({ level, expectedTargets }) => {
+        expect(level).toBeDefined();
+        expect(expectedTargets).toBeDefined();
+    });
+});

package/dist/test/llm-judgment-integration.test.js

@@ -0,0 +1,220 @@
+/**
+ * LLM-as-Judge 集成测试
+ *
+ * 测试内容：
+ * 1. LLMJudgmentClient 的 LLM 调用
+ * 2. Prompt 变体 (concise/standard/deep) 的选择
+ * 3. Skill Prompt 配置化
+ * 4. ChannelJudgmentEngine 的 LLM 集成
+ *
+ * 运行: npx tsx src/test/llm-judgment-integration.test.ts
+ */
+import { config } from 'dotenv';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { createLLMJudgmentClient, JUDGMENT_PROMPTS } from '../llm/llm-judgment-client.js';
+import { createChannelJudgmentEngine } from '../bollharness-integration/channel-judgment-engine.js';
+import { createLLMJudgmentEngine, SKILL_PROMPTS } from '../bollharness-integration/llm-judgment-engine.js';
+import * as fs from 'fs';
+config();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// 测试用例
+const TEST_CASES = [
+    {
+        input: '我们需要设计一个用户认证系统，包含登录、注册和OAuth社交登录。',
+        description: '架构设计问题',
+        expected: { approach: 'design', complexity: 'complex' }
+    },
+    {
+        input: '帮我 review 一下这段代码有没有安全问题',
+        description: '代码审查问题',
+        expected: { approach: 'analyze', skills: ['guardian-fixer'] }
+    },
+    {
+        input: '如何实现JWT token的刷新机制？',
+        description: '实现问题',
+        expected: { approach: 'implement' }
+    },
+    {
+        input: '这个任务比较复杂，帮我分解一下',
+        description: '任务分解问题',
+        expected: { approach: 'coordinate', skills: ['task-arch'] }
+    }
+];
+// 测试 Prompt 变体
+async function testPromptVariants() {
+    console.log('\n━━━ Prompt 变体测试 ━━━\n');
+    const client = await createLLMJudgmentClient({ useLLM: true });
+    for (const promptName of ['default', 'architecture', 'code', 'security']) {
+        const config = JUDGMENT_PROMPTS[promptName];
+        console.log(`[${promptName}]`);
+        console.log(`  System prompt 长度: ${config.systemPrompt.length} 字符`);
+        console.log(`  Output format: ${config.outputFormat}`);
+    }
+}
+// 测试 LLMJudgmentClient
+async function testLLMJudgmentClient() {
+    console.log('\n━━━ LLMJudgmentClient 测试 ━━━\n');
+    const client = await createLLMJudgmentClient({ useLLM: false }); // 快速模式
+    for (const tc of TEST_CASES) {
+        console.log(`测试: ${tc.description}`);
+        console.log(`输入: "${tc.input.substring(0, 40)}..."`);
+        const result = await client.judge(tc.input, {
+            senderName: 'TestUser',
+            history: ['之前的对话']
+        });
+        console.log(`  Approach: ${result.decision.approach}`);
+        console.log(`  Complexity: ${result.assessment.complexity}`);
+        console.log(`  Skills: ${result.routing.skills.join(', ')}`);
+        console.log();
+    }
+}
+// 测试 Skill Prompts 配置
+function testSkillPromptsConfig() {
+    console.log('\n━━━ Skill Prompts 配置化测试 ━━━\n');
+    const skillNames = Object.keys(SKILL_PROMPTS);
+    console.log(`已配置的 Skills: ${skillNames.join(', ')}\n`);
+    for (const [name, skill] of Object.entries(SKILL_PROMPTS)) {
+        console.log(`[${name}]`);
+        console.log(`  名称: ${skill.name}`);
+        console.log(`  描述: ${skill.description}`);
+        console.log(`  System prompt 长度: ${skill.systemPrompt.length} 字符`);
+        console.log(`  Output format: ${skill.outputFormat}`);
+        console.log();
+    }
+}
+// 测试 YAML 配置加载
+async function testYAMLConfig() {
+    console.log('\n━━━ YAML 配置文件测试 ━━━\n');
+    const yamlPath = path.join(__dirname, '../bollharness-integration/judgment-prompts.yaml');
+    try {
+        const content = fs.readFileSync(yamlPath, 'utf-8');
+        console.log(`✓ YAML 配置文件存在`);
+        console.log(`  路径: ${yamlPath}`);
+        console.log(`  大小: ${content.length} 字节`);
+        // 简单解析检查
+        const hasPromptVariants = content.includes('prompt_variants');
+        const hasSkills = content.includes('skills:');
+        const hasOutputFormats = content.includes('output_formats');
+        console.log(`  包含 Prompt 变体: ${hasPromptVariants ? '✓' : '✗'}`);
+        console.log(`  包含 Skills 配置: ${hasSkills ? '✓' : '✗'}`);
+        console.log(`  包含输出格式: ${hasOutputFormats ? '✓' : '✗'}`);
+        // 解析行数统计
+        const lines = content.split('\n').filter(l => l.trim() && !l.trim().startsWith('#'));
+        console.log(`  非注释行数: ${lines.length}`);
+    }
+    catch (err) {
+        console.error(`✗ YAML 配置文件读取失败:`, err);
+    }
+}
+// 测试 ChannelJudgmentEngine
+async function testChannelJudgmentEngine() {
+    console.log('\n━━━ ChannelJudgmentEngine 测试 ━━━\n');
+    const engine = createChannelJudgmentEngine({ useLLM: false });
+    const testInputs = [
+        '我们需要设计一个微服务架构',
+        '帮我 review 这段代码',
+        '这个功能需要安全检查',
+        '任务分解一下',
+        '实现登录功能'
+    ];
+    for (const input of testInputs) {
+        const result = await engine.decide({
+            conversationHistory: [],
+            currentMessage: input,
+            senderName: 'TestUser'
+        });
+        console.log(`输入: "${input}"`);
+        console.log(`  调用 Harness: ${result.shouldCall}`);
+        if (result.shouldCall) {
+            console.log(`  Gate: ${result.gate}`);
+            console.log(`  Skills: ${result.skills.join(', ')}`);
+            console.log(`  置信度: ${(result.confidence * 100).toFixed(0)}%`);
+        }
+        console.log();
+    }
+}
+// 测试 LLMJudgmentEngine
+async function testLLMJudgmentEngine() {
+    console.log('\n━━━ LLMJudgmentEngine 测试 ━━━\n');
+    const engine = createLLMJudgmentEngine({ useLLM: false });
+    for (const tc of TEST_CASES) {
+        console.log(`测试: ${tc.description}`);
+        const result = await engine.judge(tc.input, { history: ['之前的对话'] });
+        console.log(`  Understanding:`);
+        console.log(`    - Essence: ${result.understanding.essence}`);
+        console.log(`    - Core Need: ${result.understanding.coreNeed}`);
+        console.log(`  Assessment:`);
+        console.log(`    - Complexity: ${result.assessment.complexity}`);
+        console.log(`    - Depth: ${result.assessment.depth}`);
+        console.log(`  Decision:`);
+        console.log(`    - Approach: ${result.decision.approach}`);
+        console.log(`  Routing:`);
+        console.log(`    - Skills: ${result.routing.skills.join(', ')}`);
+        console.log(`    - Collaboration: ${result.routing.collaboration}`);
+        console.log();
+    }
+}
+// 测试 DynamicSkillRouter
+async function testDynamicSkillRouter() {
+    console.log('\n━━━ DynamicSkillRouter 测试 ━━━\n');
+    const { createDynamicSkillRouter } = await import('../bollharness-integration/llm-judgment-engine.js');
+    const router = createDynamicSkillRouter({ useLLM: false });
+    const availableSkills = router.listSkills();
+    console.log(`可用的 Skills: ${availableSkills.join(', ')}`);
+    // 测试单个 Skill 调用
+    const judgment = {
+        understanding: {
+            essence: 'how-to',
+            coreNeed: '设计方案',
+            implicit: []
+        },
+        assessment: {
+            complexity: 'complex',
+            complexityReason: '涉及架构设计',
+            depth: 'deeper',
+            urgency: 'medium'
+        },
+        decision: {
+            approach: 'design',
+            reasoning: '需要架构设计'
+        },
+        routing: {
+            skills: ['arch'],
+            agents: [],
+            collaboration: 'pair'
+        },
+        artifacts: {
+            required: ['架构文档']
+        }
+    };
+    const results = await router.routeAndExecute('设计一个电商系统', judgment);
+    console.log(`\nSkill 执行结果:`);
+    for (const [skill, result] of Object.entries(results)) {
+        console.log(`  ${skill}: ${String(result).substring(0, 100)}...`);
+    }
+}
+// 主测试函数
+async function main() {
+    console.log('========================================');
+    console.log('  LLM-as-Judge 集成测试');
+    console.log('========================================');
+    try {
+        await testPromptVariants();
+        await testLLMJudgmentClient();
+        testSkillPromptsConfig();
+        await testYAMLConfig();
+        await testChannelJudgmentEngine();
+        await testLLMJudgmentEngine();
+        await testDynamicSkillRouter();
+        console.log('\n========================================');
+        console.log('  测试完成 ✓');
+        console.log('========================================\n');
+    }
+    catch (err) {
+        console.error('\n测试失败:', err);
+        process.exit(1);
+    }
+}
+main();