@bolloon/bolloon-agent 0.1.0

package/src/test/harness-judgment-injection.test.ts

@@ -0,0 +1,353 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  generateJudgmentInjection,
+  getCoreJudgmentsForSession,
+  getJudgmentsForPath,
+  getJudgmentsForFragment,
+  getJudgmentsForContextRequest,
+  type JudgmentInjectOptions,
+} from '../bollharness-integration/context-router-judgment.js';
+import * as judgmentModule from '../pi-ecosystem-judgment/index.js';
+
+describe('Harness Judgment Injection - Gate Integration', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Gate-specific judgment injection', () => {
+    it('should inject core judgments at Gate 0 (session start)', async () => {
+      const injection = await generateJudgmentInjection('src/agents/', 0);
+
+      expect(injection).toContain('# User Core Values');
+      expect(injection).toContain('core_judgments:');
+      expect(injection).toContain('confidence: 0.9');
+    });
+
+    it('should inject path judgments at Gate 3 (plan freeze)', async () => {
+      const injection = await generateJudgmentInjection('src/agents/', 3);
+
+      expect(injection).toContain('# Plan Freeze');
+      expect(injection).toContain('active_judgments:');
+    });
+
+    it('should return path judgments for Gate 1 (not core)', async () => {
+      const injection = await generateJudgmentInjection('src/agents/', 1);
+
+      expect(injection).toContain('# Gate 1');
+      expect(injection).not.toContain('core_judgments:');
+    });
+
+    it('should include confidence in injection header', async () => {
+      const injection = await generateJudgmentInjection('src/agents/', 3);
+
+      expect(injection).toMatch(/# Confidence: \d+%/);
+    });
+
+    it('should include file path in injection header', async () => {
+      const injection = await generateJudgmentInjection('src/agents/', 3);
+
+      expect(injection).toContain('# Path: src/agents/');
+    });
+  });
+
+  describe('Path-based judgment routing', () => {
+    it('should route src/agents/ to agent-related fragments', async () => {
+      const result = await getJudgmentsForPath('src/agents/');
+
+      expect(result.fragments).toBeDefined();
+      expect(Array.isArray(result.fragments)).toBe(true);
+    });
+
+    it('should return judgments sorted by confidence', async () => {
+      const result = await getJudgmentsForPath('src/agents/');
+
+      if (result.judgments.length > 1) {
+        for (let i = 1; i < result.judgments.length; i++) {
+          expect(result.judgments[i - 1].confidence).toBeGreaterThanOrEqual(
+            result.judgments[i].confidence
+          );
+        }
+      }
+    });
+
+    it('should filter judgments by minimum confidence', async () => {
+      const result = await getJudgmentsForPath('src/agents/', { minConfidence: 0.9 });
+
+      for (const j of result.judgments) {
+        expect(j.confidence).toBeGreaterThanOrEqual(0.9);
+      }
+    });
+
+    it('should limit number of judgments', async () => {
+      const result = await getJudgmentsForPath('src/agents/', { maxJudgments: 3 });
+
+      expect(result.judgments.length).toBeLessThanOrEqual(3);
+    });
+
+    it('should calculate overall confidence for path', async () => {
+      const result = await getJudgmentsForPath('src/agents/');
+
+      expect(typeof result.confidence).toBe('number');
+      expect(result.confidence).toBeGreaterThanOrEqual(0);
+      expect(result.confidence).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('Fragment to judgment mapping', () => {
+    it('should map agent-architecture fragment to agent contexts', async () => {
+      const judgments = await getJudgmentsForFragment('agent-architecture');
+
+      expect(Array.isArray(judgments)).toBe(true);
+    });
+
+    it('should map testing-patterns fragment to testing contexts', async () => {
+      const judgments = await getJudgmentsForFragment('testing-patterns');
+
+      expect(Array.isArray(judgments)).toBe(true);
+    });
+
+    it('should return empty for unknown fragment', async () => {
+      const judgments = await getJudgmentsForFragment('unknown-fragment-xyz');
+
+      expect(Array.isArray(judgments)).toBe(true);
+    });
+
+    it('should deduplicate judgments across fragments', async () => {
+      const result = await getJudgmentsForPath('src/agents/');
+
+      const ids = result.judgments.map(j => j.id);
+      const uniqueIds = new Set(ids);
+      expect(ids.length).toBe(uniqueIds.size);
+    });
+  });
+
+  describe('Core judgments for session', () => {
+    it('should only include human source judgments', async () => {
+      const injection = await getCoreJudgmentsForSession(0.9);
+
+      if (injection.length > 0) {
+        expect(injection).toContain('core_judgments:');
+      }
+    });
+
+    it('should filter by minimum confidence', async () => {
+      const injection = await getCoreJudgmentsForSession(0.95);
+
+      if (injection.length > 0) {
+        expect(injection).toContain('confidence: 0.95');
+      }
+    });
+
+    it('should limit to 10 judgments', async () => {
+      const injection = await getCoreJudgmentsForSession(0.5);
+
+      const matches = injection.match(/principle:/g);
+      if (matches) {
+        expect(matches.length).toBeLessThanOrEqual(10);
+      }
+    });
+
+    it('should return empty string when no judgments meet threshold', async () => {
+      const injection = await getCoreJudgmentsForSession(1.0);
+
+      expect(typeof injection).toBe('string');
+    });
+  });
+
+  describe('Judgment formatting', () => {
+    it('should format judgments as YAML by default', async () => {
+      const result = await getJudgmentsForPath('src/agents/', { format: 'yaml' });
+
+      expect(result.contextYaml).toContain('active_judgments:');
+    });
+
+    it('should format judgments as JSON', async () => {
+      const result = await getJudgmentsForPath('src/agents/', { format: 'json' });
+
+      expect(result.contextYaml).toContain('[');
+      expect(() => JSON.parse(result.contextYaml)).not.toThrow();
+    });
+
+    it('should format judgments as text', async () => {
+      const result = await getJudgmentsForPath('src/agents/', { format: 'text' });
+
+      expect(result.contextYaml).toMatch(/\[\d+%\]/);
+    });
+
+    it('should escape YAML strings correctly', async () => {
+      const result = await getJudgmentsForPath('src/agents/', { format: 'yaml' });
+
+      expect(result.contextYaml).not.toContain('\n"');
+    });
+  });
+
+  describe('Context-specific judgment requests', () => {
+    it('should get judgments for explicit context', async () => {
+      const result = await getJudgmentsForContextRequest('typescript');
+
+      expect(result).toHaveProperty('judgments');
+      expect(result).toHaveProperty('confidence');
+      expect(result).toHaveProperty('contextYaml');
+    });
+
+    it('should filter by context match', async () => {
+      const result = await getJudgmentsForContextRequest('code-quality');
+
+      for (const j of result.judgments) {
+        const hasMatch = j.context?.toLowerCase().includes('code-quality') ||
+                        j.context?.toLowerCase().includes('quality') ||
+                        j.context?.toLowerCase().includes('development');
+        expect(hasMatch).toBeTruthy();
+      }
+    });
+  });
+});
+
+describe('Harness Judgment Injection - Multi-Agent Scenarios', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Decision level with harness context', () => {
+    it('should route consult_internal to colony_ant and subagent', async () => {
+      vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.5);
+
+      const { evaluateDecision } = await import('../pi-ecosystem-judgment/decision.js');
+      const request = await evaluateDecision(
+        'Delegate task to colony ant',
+        'delegation',
+        'agent-001',
+        0.7
+      );
+
+      expect(request.targets).toContain('colony_ant');
+      expect(request.targets).toContain('subagent');
+      expect(request.targets).not.toContain('p2p_agent');
+    });
+
+    it('should route consult_external to p2p_agent', async () => {
+      vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.35);
+
+      const { evaluateDecision } = await import('../pi-ecosystem-judgment/decision.js');
+      const request = await evaluateDecision(
+        'Cross-system protocol negotiation',
+        'protocol',
+        'agent-001',
+        0.7
+      );
+
+      expect(request.targets).toContain('p2p_agent');
+      expect(request.targets).toContain('colony_ant');
+      expect(request.targets).toContain('subagent');
+    });
+
+    it('should escalate to human for strategic decisions', async () => {
+      vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.2);
+
+      const { evaluateDecision } = await import('../pi-ecosystem-judgment/decision.js');
+      const request = await evaluateDecision(
+        'Strategic pivot decision',
+        'strategy',
+        'agent-001',
+        0.7
+      );
+
+      expect(request.targets).toEqual(['human']);
+    });
+  });
+
+  describe('Judgment confidence propagation', () => {
+    it('should use harness path confidence for decision routing', async () => {
+      const result = await getJudgmentsForPath('src/agents/');
+
+      vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(result.confidence);
+
+      const { evaluateDecision } = await import('../pi-ecosystem-judgment/decision.js');
+      const request = await evaluateDecision(
+        'Agent architecture decision',
+        'architecture',
+        'agent-001',
+        0.7
+      );
+
+      if (result.confidence >= 0.7) {
+        expect(request.level).toBe('autonomous');
+      } else if (result.confidence >= 0.49) {
+        expect(request.level).toBe('consult_internal');
+      } else if (result.confidence >= 0.28) {
+        expect(request.level).toBe('consult_external');
+      } else {
+        expect(request.level).toBe('require_human');
+      }
+    });
+  });
+});
+
+describe('Harness Judgment Injection - Gate Confidence Thresholds', () => {
+  const gateThresholds: Array<{ gate: number; expectedMinConfidence: number; description: string }> = [
+    { gate: 0, expectedMinConfidence: 0.9, description: 'Session start - highest bar' },
+    { gate: 1, expectedMinConfidence: 0.8, description: 'Architecture design' },
+    { gate: 2, expectedMinConfidence: 0.75, description: 'Review' },
+    { gate: 3, expectedMinConfidence: 0.8, description: 'Plan freeze' },
+    { gate: 5, expectedMinConfidence: 0.7, description: 'Task architecture' },
+    { gate: 7, expectedMinConfidence: 0.7, description: 'Execution' },
+  ];
+
+  it.each(gateThresholds)(
+    'Gate $gate ($description) should use minConfidence $expectedMinConfidence',
+    async ({ gate, expectedMinConfidence }) => {
+      const injection = await generateJudgmentInjection('src/agents/', gate);
+
+      if (gate === 0 || gate === 1 || gate === 2 || gate === 3 || gate === 5 || gate === 7) {
+        expect(injection).toBeDefined();
+        expect(typeof injection).toBe('string');
+      }
+    }
+  );
+
+  it('should return path judgments for all non-zero gates', async () => {
+    for (const gate of [1, 2, 4, 5, 6, 8, 9]) {
+      const injection = await generateJudgmentInjection('src/agents/', gate);
+      expect(typeof injection).toBe('string');
+    }
+  });
+});
+
+describe('Harness Judgment Injection - End-to-End Flow', () => {
+  it('should produce injectable YAML for agent context', async () => {
+    const injection = await generateJudgmentInjection('src/agents/', 0);
+
+    const hasValidYamlStructure =
+      injection.includes('core_judgments:') ||
+      injection.includes('active_judgments:') ||
+      injection.includes('# User Core Values');
+
+    expect(hasValidYamlStructure).toBeTruthy();
+  });
+
+  it('should format judgments for LLM consumption', async () => {
+    const result = await getJudgmentsForPath('src/agents/', { format: 'yaml' });
+
+    const lines = result.contextYaml.split('\n');
+    const hasPrinciple = lines.some(line => line.includes('principle:'));
+    const hasConfidence = lines.some(line => line.includes('confidence:'));
+
+    expect(hasPrinciple || hasConfidence).toBeTruthy();
+  });
+
+  it('should fallback to general-dev-principles for unknown paths', async () => {
+    const result = await getJudgmentsForPath('/nonexistent/path/that/matches/nothing');
+
+    expect(result).toHaveProperty('judgments');
+    expect(result).toHaveProperty('confidence');
+    expect(result.fragments).toContain('general-dev-principles');
+  });
+
+  it('should provide traceability from path to fragment to judgment', async () => {
+    const result = await getJudgmentsForPath('src/agents/');
+
+    expect(result.fragments.length).toBeGreaterThan(0);
+    expect(result.judgments.length).toBeGreaterThanOrEqual(0);
+    expect(typeof result.confidence).toBe('number');
+  });
+});

package/src/test/harness-workflow-integrator-test.ts

@@ -0,0 +1,285 @@
+/**
+ * Harness Workflow Integrator Test
+ *
+ * 测试 Channel Agent 与 Bollharness 配置系统的集成
+ *
+ * 运行: npx tsx src/test/harness-workflow-integrator-test.ts
+ */
+
+import { config } from 'dotenv';
+import {
+  createHarnessWorkflowIntegrator,
+  HarnessWorkflowIntegrator
+} from '../social/channels/harness-workflow-integrator.js';
+import {
+  createChannelAgent,
+  ChannelAgent
+} from '../social/channels/channel-agent-session.js';
+import { createChannelJudgmentEngine } from '../bollharness-integration/channel-judgment-engine.js';
+
+config();
+
+async function testWorkflowIntegrator() {
+  console.log('\n========================================');
+  console.log('  Harness Workflow Integrator 测试');
+  console.log('========================================\n');
+
+  const integrator = createHarnessWorkflowIntegrator();
+  await integrator.initialize();
+
+  console.log('━━━ Gate 状态测试 ━━━\n');
+
+  // 测试 Gate 状态
+  let status = integrator.getWorkflowStatus();
+  console.log(`当前 Gate: ${status.gateName} (${status.progress})`);
+  console.log(`Blockers: ${status.blockers.length > 0 ? status.blockers.join(', ') : '无'}`);
+
+  // 提交产物
+  console.log('\n提交产物到 Gate 0...');
+  integrator.submitArtifact('user_request', '设计一个用户认证系统');
+  integrator.submitArtifact('change_classification', 'implementation');
+
+  // 测试 Gate 转移
+  console.log('\n尝试转移到 Gate 1...');
+  let result = await integrator.transitionGate();
+  console.log(`转移结果: ${result.message}`);
+  console.log(`Success: ${result.success}`);
+
+  status = integrator.getWorkflowStatus();
+  console.log(`\n当前 Gate: ${status.gateName} (${status.progress})`);
+
+  // 测试 Skill 路由
+  console.log('\n━━━ Skill 路由测试 ━━━\n');
+
+  const testMessages = [
+    '帮我设计一个微服务架构',
+    'review 一下这段代码',
+    '我们需要实现用户登录功能',
+    '帮我分解这个任务',
+    '测试一下代码覆盖率',
+    '分析一下系统的安全性'
+  ];
+
+  for (const msg of testMessages) {
+    const skills = integrator.routeSkillsByKeyword(msg);
+    console.log(`"${msg}"`);
+    console.log(`  → Skills: ${skills.join(', ')}`);
+    console.log('');
+  }
+
+  // 测试 Gate Pack
+  console.log('━━━ Gate Pack 测试 ━━━\n');
+
+  const gatePack = integrator.getGatePack();
+  console.log('当前 Gate Pack:');
+  console.log(JSON.stringify(gatePack, null, 2));
+
+  console.log('\n========================================\n');
+}
+
+async function testAgentWithHarness() {
+  console.log('\n========================================');
+  console.log('  Channel Agent + Harness 集成测试');
+  console.log('========================================\n');
+
+  // 创建 Agent
+  const alice = createChannelAgent({
+    name: 'Alice',
+    port: 9101,
+    domain: '架构',
+    capabilities: ['架构设计', '代码审查', '任务分解']
+  });
+
+  const integrator = createHarnessWorkflowIntegrator();
+  await integrator.initialize();
+
+  await alice.start();
+
+  console.log('━━━ 多轮对话 + Harness + Gate 测试 ━━━\n');
+
+  const script = [
+    {
+      from: 'Alice',
+      content: 'Bob，我们需要设计一个新的微服务架构。',
+      expectedGate: 1
+    },
+    {
+      from: 'Bob',
+      content: '好的，我来帮你分析架构设计。',
+      expectedGate: 1
+    },
+    {
+      from: 'Alice',
+      content: '帮我 review 一下代码实现。',
+      expectedGate: 2
+    },
+    {
+      from: 'Bob',
+      content: '代码审查完成，需要优化错误处理。',
+      expectedGate: 0
+    },
+    {
+      from: 'Alice',
+      content: '好的，现在分解任务，制定开发计划。',
+      expectedGate: 5
+    },
+    {
+      from: 'Bob',
+      content: '任务已分解为 4 个子任务。',
+      expectedGate: 5
+    }
+  ];
+
+  let harnessCallCount = 0;
+  const gateStats = new Map<number, number>();
+
+  for (let i = 0; i < script.length; i++) {
+    const { from, content, expectedGate } = script[i];
+    const to = from === 'Alice' ? 'Bob' : 'Alice';
+
+    console.log(`[${from}] >>> ${content}`);
+
+    // 通过 Agent 处理
+    const result = await alice.receiveMessage(from, content);
+
+    // 路由 Skill
+    const skills = integrator.routeSkillsByKeyword(content);
+
+    console.log(`[${to}] 处理结果:`);
+    console.log(`  🧠 Harness调用: ${result.harnessCalled ? '是' : '否'}`);
+    if (result.harnessCalled) {
+      console.log(`  Gate ${result.gate}`);
+      console.log(`  Skills: ${skills.join(', ')}`);
+      harnessCallCount++;
+      gateStats.set(result.gate!, (gateStats.get(result.gate!) || 0) + 1);
+
+      if (result.gate !== expectedGate) {
+        console.log(`  ⚠️ 期望 Gate ${expectedGate}`);
+      }
+    }
+    console.log(`  回复: ${result.response.substring(0, 60)}...`);
+    console.log('');
+
+    await new Promise(r => setTimeout(r, 200));
+  }
+
+  console.log('━━━ 结果汇总 ━━━\n');
+  console.log(`Harness 调用次数: ${harnessCallCount}`);
+  console.log('\nGate 统计:');
+
+  const gateNames: Record<number, string> = {
+    1: '架构设计',
+    2: '代码审查',
+    4: '安全检查',
+    5: '任务分解',
+    7: '代码实现',
+    8: '测试验证'
+  };
+
+  for (const [gate, count] of Array.from(gateStats.entries()).sort((a, b) => a[0] - b[0])) {
+    console.log(`  Gate ${gate} (${gateNames[gate] || '未知'}): ${count} 次`);
+  }
+
+  console.log('\n当前工作流状态:');
+  const status = integrator.getWorkflowStatus();
+  console.log(`  ${status.gateName} (${status.progress})`);
+
+  const success = harnessCallCount >= 3;
+  console.log(`\n${success ? '✅' : '⚠️'} ${success ? '测试成功' : '测试失败'}`);
+
+  alice.shutdown();
+
+  console.log('\n========================================\n');
+
+  return success;
+}
+
+async function testSkillRouting() {
+  console.log('\n========================================');
+  console.log('  Skill 路由测试');
+  console.log('========================================\n');
+
+  const integrator = createHarnessWorkflowIntegrator();
+  await integrator.initialize();
+
+  const judgmentEngine = createChannelJudgmentEngine();
+
+  const testCases = [
+    {
+      message: '帮我设计一个三层架构方案',
+      expectedKeywords: ['架构', '设计'],
+      expectedSkills: ['arch', 'lead']
+    },
+    {
+      message: 'review 一下登录模块的实现',
+      expectedKeywords: ['review'],
+      expectedSkills: ['guardian-fixer', 'arch']
+    },
+    {
+      message: '系统需要支持 OAuth2 认证',
+      expectedKeywords: ['认证'],
+      expectedSkills: ['guardian-fixer', 'arch']
+    },
+    {
+      message: '把这个任务分解成可执行的子任务',
+      expectedKeywords: ['任务', '分解'],
+      expectedSkills: ['task-arch', 'harness-eng']
+    },
+    {
+      message: '帮我写用户注册模块的代码',
+      expectedKeywords: ['写代码', '实现'],
+      expectedSkills: ['harness-dev', 'harness-eng']
+    },
+    {
+      message: '运行单元测试验证功能',
+      expectedKeywords: ['测试', '验证'],
+      expectedSkills: ['harness-eng-test', 'guardian-fixer']
+    }
+  ];
+
+  console.log('━━━ 测试用例 ━━━\n');
+
+  let passed = 0;
+  for (const tc of testCases) {
+    // 通过 JudgmentEngine 判断
+    const context = {
+      conversationHistory: [],
+      currentMessage: tc.message
+    };
+    const judgment = judgmentEngine.decide(context);
+
+    // 通过 Integrator 路由 Skill
+    const skills = integrator.routeSkillsByKeyword(tc.message);
+
+    const judgmentGateMatch = judgment.shouldCall;
+    const skillMatch = skills.some(s => tc.expectedSkills.includes(s));
+
+    const status = judgmentGateMatch && skillMatch ? '✅' : '⚠️';
+
+    console.log(`${status} "${tc.message}"`);
+    console.log(`   Judgment: ${judgment.shouldCall ? `Gate ${judgment.gate}` : '无需 Harness'}`);
+    console.log(`   Skills: ${skills.join(', ') || '无'}`);
+
+    if (judgment.shouldCall && skillMatch) passed++;
+
+    console.log('');
+  }
+
+  console.log(`通过率: ${passed}/${testCases.length}`);
+
+  console.log('\n========================================\n');
+}
+
+async function main() {
+  try {
+    await testWorkflowIntegrator();
+    await testSkillRouting();
+    await testAgentWithHarness();
+    process.exit(0);
+  } catch (err) {
+    console.error('测试失败:', err);
+    process.exit(1);
+  }
+}
+
+main();