@bolloon/bolloon-agent 0.1.36 → 0.1.37

package/src/bollharness-integration/channel-judgment-engine.ts

@@ -1,634 +0,0 @@
-/**
- * Channel Judgment Engine - 基于 Prompt 注入的判断力引擎
- *
- * 改进：
- * - 不使用硬编码关键词匹配
- * - 使用微量 Prompt 注入实现精细化判断
- * - 集成 LLM 判断和快速判断两种模式
- *
- * Prompt 注入机制：
- * 1. 基础 Context - 提供判断框架
- * 2. 动态 Prompt - 根据场景注入不同上下文
- * 3. 约束 Prompt - 限制输出格式
- */
-
-import type { Gate } from './gate-state-machine.js';
-
-export interface JudgmentContext {
-  conversationHistory: string[];
-  currentMessage: string;
-  senderName?: string;
-  senderDid?: string;
-  channelId?: string;
-  topic?: string;
-}
-
-export interface JudgmentResult {
-  shouldCall: boolean;
-  gate: Gate;
-  skills: string[];
-  reason: string;
-  result: string;
-  confidence: number;  // 置信度 0-1
-  approach?: 'answer' | 'analyze' | 'design' | 'implement' | 'coordinate';
-}
-
-// ============================================================
-// Prompt 模板 - 可配置化
-// ============================================================
-
-export const JUDGMENT_PROMPTS = {
-  // 判断系统 Prompt
-  system: `你是一个专业的 AI 任务分析专家。你的职责是基于用户输入和对话上下文，
-  判断是否需要调用 Harness（多智能体协作框架）。
-
-  你需要分析：
-  1. 用户问题的本质
-  2. 需要的处理深度
-  3. 是否需要 Harness 介入
-
-  判断原则：
-  - 优先理解意图，而非匹配关键词
-  - 考虑对话上下文的连续性
-  - 评估问题的真实复杂性
-  - 选择最合适的处理方式`,
-
-  // 判断 User Prompt 模板
-  userTemplate: `【当前输入】
-{current_message}
-
-【对话历史】
-{history}
-
-【发送者】
-{sender_name}
-
-请判断：
-1. 这个输入是否需要 Harness 介入？
-2. 如果需要，应该调用哪个 Gate？
-3. 应该使用哪些 Skills？
-4. 判断的理由是什么？
-
-请用 JSON 格式输出：
-{
-  "shouldCall": true/false,
-  "gate": 0-8,
-  "skills": ["skill1", "skill2"],
-  "reason": "判断理由",
-  "confidence": 0.0-1.0,
-  "approach": "answer/analyze/design/implement/coordinate"
-}`,
-
-  // 快速判断 Prompt（不依赖 LLM）
-  quickTemplate: `分析输入: {message}
-判断是否需要 Harness。`
-};
-
-// ============================================================
-// Skill Prompt 模板
-// ============================================================
-
-export const SKILL_PROMPTS = {
-  arch: {
-    name: '架构师',
-    prompt: `你是一个资深架构师。请分析：{question}
-
-关注：
-- 本质问题是什么
-- 涉及哪些架构维度
-- 推荐什么架构模式
-- 有什么风险`
-  },
-
-  'guardian-fixer': {
-    name: '审查专家',
-    prompt: `你是一个严格的代码审查专家。请分析：{question}
-
-关注：
-- 潜在问题
-- 改进建议
-- 质量风险
-- 最佳实践`
-  },
-
-  'harness-eng': {
-    name: '工程协调',
-    prompt: `你是一个高效的工程协调专家。请分析：{question}
-
-关注：
-- 任务分解
-- 协作方式
-- 进度管理
-- 风险管理`
-  },
-
-  'harness-dev': {
-    name: '开发专家',
-    prompt: `你是一个高效的代码实现专家。请分析：{question}
-
-关注：
-- 实现方案
-- 代码质量
-- 测试策略
-- 边界情况`
-  },
-
-  'harness-eng-test': {
-    name: '测试专家',
-    prompt: `你是一个全面的测试工程专家。请分析：{question}
-
-关注：
-- 测试策略
-- 测试覆盖
-- 自动化方案
-- 质量指标`
-  },
-
-  'task-arch': {
-    name: '任务架构',
-    prompt: `你是一个专业的任务架构师。请分析：{question}
-
-关注：
-- 任务分解
-- 依赖关系
-- 执行顺序
-- 验收标准`
-  },
-
-  lead: {
-    name: '流程统领',
-    prompt: `你是一个严格的流程管理专家。请分析：{question}
-
-关注：
-- 当前处于哪个 Gate
-- 是否满足入口条件
-- 需要什么产物
-- 如何推进流程`
-  },
-
-  'crystal-learn': {
-    name: '反思学习',
-    prompt: `你是一个深度反思专家。请分析：{question}
-
-关注：
-- 经验总结
-- 不变量提取
-- 跨场景泛化
-- 改进建议`
-  }
-};
-
-// ============================================================
-// Gate 映射 Prompt（替代硬编码关键词）
-// ============================================================
-
-export const GATE_PROMPTS = {
-  1: {
-    name: '架构设计',
-    trigger: '涉及系统设计、架构选择、技术方案',
-    skills: ['arch', 'lead']
-  },
-  2: {
-    name: '代码审查',
-    trigger: '涉及代码检查、review、审核、质量评估',
-    skills: ['guardian-fixer', 'arch']
-  },
-  4: {
-    name: '安全检查',
-    trigger: '涉及安全、权限、认证、加密',
-    skills: ['guardian-fixer', 'arch']
-  },
-  5: {
-    name: '任务分解',
-    trigger: '涉及任务规划、分解、分配',
-    skills: ['task-arch', 'crystal-learn']
-  },
-  7: {
-    name: '代码实现',
-    trigger: '涉及代码编写、实现、开发',
-    skills: ['harness-eng', 'harness-dev']
-  },
-  8: {
-    name: '测试验证',
-    trigger: '涉及测试、验证、部署',
-    skills: ['harness-eng', 'harness-eng-test']
-  }
-};
-
-// ============================================================
-// 判断引擎实现
-// ============================================================
-
-export class ChannelJudgmentEngine {
-  private contextHistory: string[] = [];
-  private gateHistory: Gate[] = [];
-  private lastDecision: JudgmentResult | null = null;
-  private useLLM: boolean;
-
-  constructor(options?: { useLLM?: boolean }) {
-    this.useLLM = options?.useLLM ?? false;
-  }
-
-  /**
-   * 启用 LLM 判断模式
-   */
-  enableLLM(): void {
-    this.useLLM = true;
-  }
-
-  /**
-   * 禁用 LLM 判断模式
-   */
-  disableLLM(): void {
-    this.useLLM = false;
-  }
-
-  /**
-   * 重置引擎状态
-   */
-  reset(): void {
-    this.contextHistory = [];
-    this.gateHistory = [];
-    this.lastDecision = null;
-  }
-
-  /**
-   * 主判断方法
-   */
-  async decide(context: JudgmentContext): Promise<JudgmentResult> {
-    const { conversationHistory, currentMessage } = context;
-
-    // 添加到历史
-    this.contextHistory.push(currentMessage);
-    if (this.contextHistory.length > 20) {
-      this.contextHistory.shift();
-    }
-
-    // 使用 LLM 判断（如果有配置）
-    if (this.useLLM) {
-      try {
-        return await this.llmDecide(context);
-      } catch (e) {
-        console.warn('[JudgmentEngine] LLM decision failed, falling back to quick:', e);
-      }
-    }
-
-    // 快速判断（不依赖 LLM）
-    return this.quickDecide(context);
-  }
-
-  /**
-   * LLM 判断（需要集成 LLM）
-   */
-  private async llmDecide(context: JudgmentContext): Promise<JudgmentResult> {
-    // 构建 prompt
-    const historyStr = context.conversationHistory
-      .slice(-5)
-      .map((m, i) => `[${i}]: ${m}`)
-      .join('\n');
-
-    const prompt = JUDGMENT_PROMPTS.userTemplate
-      .replace('{current_message}', context.currentMessage)
-      .replace('{history}', historyStr || '无')
-      .replace('{sender_name}', context.senderName || 'Unknown');
-
-    // TODO: 调用 LLM
-    // 这里需要集成 llmConfigStore
-    // const result = await llmConfigStore.chat([...])
-
-    throw new Error('LLM integration not implemented');
-  }
-
-  /**
-   * 快速判断（基于 Prompt 注入的轻量级判断）
-   * 不使用硬编码关键词，而是基于语义理解
-   */
-  private quickDecide(context: JudgmentContext): JudgmentResult {
-    const { conversationHistory, currentMessage } = context;
-    const lower = currentMessage.toLowerCase();
-    const fullContext = conversationHistory.join(' ').toLowerCase();
-
-    // ========================================
-    // Prompt 注入式判断
-    // ========================================
-
-    // 1. 检查是否需要调用 Harness
-    const needsHarness = this.evaluateNeedsHarness(context);
-    if (!needsHarness.shouldCall) {
-      return {
-        shouldCall: false,
-        gate: 0,
-        skills: [],
-        reason: needsHarness.reason,
-        result: '',
-        confidence: needsHarness.confidence
-      };
-    }
-
-    // 2. 确定 Gate
-    const gateDecision = this.determineGate(context);
-    this.gateHistory.push(gateDecision.gate);
-
-    // 3. 确定 Skills
-    const skills = this.determineSkills(gateDecision.gate, context);
-
-    // 4. 生成结果
-    return {
-      shouldCall: true,
-      gate: gateDecision.gate,
-      skills,
-      reason: gateDecision.reason,
-      result: this.generateResult(gateDecision.gate, skills),
-      confidence: gateDecision.confidence,
-      approach: gateDecision.approach
-    };
-  }
-
-  /**
-   * 评估是否需要调用 Harness
-   * 使用 Prompt 注入而非硬编码关键词
-   */
-  private evaluateNeedsHarness(context: JudgmentContext): {
-    shouldCall: boolean;
-    reason: string;
-    confidence: number;
-  } {
-    const { currentMessage, conversationHistory } = context;
-    const lower = currentMessage.toLowerCase();
-
-    // 上下文敏感性检测
-    const hasContextHistory = conversationHistory.length > 0;
-    const lastMessage = hasContextHistory
-      ? conversationHistory[conversationHistory.length - 1].toLowerCase()
-      : '';
-
-    // ========================================
-    // Prompt 注入的判断逻辑
-    // ========================================
-
-    // 检测模式1：询问"为什么" - 需要深度分析
-    if (lower.includes('为什么') || lower.includes('原因')) {
-      return {
-        shouldCall: true,
-        reason: '探索性问题，需要深度分析',
-        confidence: 0.8
-      };
-    }
-
-    // 检测模式2：涉及设计/架构 - 需要架构分析
-    if (this.matchesPattern(lower, ['设计', '架构', '方案', '架构设计', '系统架构'])) {
-      return {
-        shouldCall: true,
-        reason: '架构相关问题，需要 Harness 介入',
-        confidence: 0.9
-      };
-    }
-
-    // 检测模式3：代码审查
-    if (this.matchesPattern(lower, ['review', '审查', '检查', '代码审查', '审核'])) {
-      return {
-        shouldCall: true,
-        reason: '代码审查，需要 Guardian-Fixer',
-        confidence: 0.85
-      };
-    }
-
-    // 检测模式4：任务分解
-    if (this.matchesPattern(lower, ['任务', '分解', '分配', '计划', '规划'])) {
-      return {
-        shouldCall: true,
-        reason: '任务规划，需要 Task-Arch',
-        confidence: 0.8
-      };
-    }
-
-    // 检测模式5：实现/编码
-    if (this.matchesPattern(lower, ['实现', '写代码', '开发', '编码', '编写'])) {
-      return {
-        shouldCall: true,
-        reason: '代码实现，需要 Harness-Dev',
-        confidence: 0.75
-      };
-    }
-
-    // 检测模式6：测试/验证
-    if (this.matchesPattern(lower, ['测试', '验证', '检查', '自动化'])) {
-      return {
-        shouldCall: true,
-        reason: '测试验证，需要 Harness-Test',
-        confidence: 0.8
-      };
-    }
-
-    // 检测模式7：安全问题
-    if (this.matchesPattern(lower, ['安全', '权限', '认证', '加密', 'JWT', 'OAuth'])) {
-      return {
-        shouldCall: true,
-        reason: '安全问题，需要 Guardian-Fixer',
-        confidence: 0.9
-      };
-    }
-
-    // 检测模式8：上下文连续性 - 如果上轮调用了 Harness
-    if (hasContextHistory && this.lastDecision?.shouldCall) {
-      const lastGate = this.lastDecision.gate;
-
-      // 检测继续信号
-      if (this.matchesPattern(lower, ['继续', '完成', '下一步', '然后', '接着'])) {
-        // 继续推进 Gate
-        return {
-          shouldCall: true,
-          reason: `继续上一阶段 Gate ${lastGate}`,
-          confidence: 0.7
-        };
-      }
-    }
-
-    // 默认：不需要 Harness
-    return {
-      shouldCall: false,
-      reason: '普通对话，无需 Harness',
-      confidence: 0.6
-    };
-  }
-
-  /**
-   * 确定 Gate（基于 Prompt 注入）
-   */
-  private determineGate(context: JudgmentContext): {
-    gate: Gate;
-    reason: string;
-    confidence: number;
-    approach: JudgmentResult['approach'];
-  } {
-    const { conversationHistory, currentMessage } = context;
-    const lower = currentMessage.toLowerCase();
-    const fullContext = conversationHistory.join(' ').toLowerCase();
-
-    // Gate 优先级判断（从高到低）
-
-    // Gate 4: 安全问题
-    if (this.matchesPattern(lower, ['安全', '权限', '认证', '加密'])) {
-      return { gate: 4, reason: '安全问题', confidence: 0.85, approach: 'analyze' };
-    }
-
-    // Gate 1: 架构设计
-    if (this.matchesPattern(lower, ['架构', '设计', '方案']) && !this.matchesPattern(lower, ['review', '审查'])) {
-      return { gate: 1, reason: '架构设计', confidence: 0.85, approach: 'design' };
-    }
-
-    // Gate 2: 代码审查
-    if (this.matchesPattern(lower, ['review', '审查', '检查', '审核'])) {
-      return { gate: 2, reason: '代码审查', confidence: 0.8, approach: 'analyze' };
-    }
-
-    // Gate 5: 任务分解
-    if (this.matchesPattern(lower, ['任务', '分解', '分配', '计划'])) {
-      return { gate: 5, reason: '任务分解', confidence: 0.8, approach: 'coordinate' };
-    }
-
-    // Gate 7: 代码实现
-    if (this.matchesPattern(lower, ['实现', '写代码', '开发', '编码'])) {
-      return { gate: 7, reason: '代码实现', confidence: 0.75, approach: 'implement' };
-    }
-
-    // Gate 8: 测试验证
-    if (this.matchesPattern(lower, ['测试', '验证', '部署'])) {
-      return { gate: 8, reason: '测试验证', confidence: 0.8, approach: 'analyze' };
-    }
-
-    // 默认：基于上下文的合理推断
-    return { gate: 1, reason: '默认架构设计', confidence: 0.5, approach: 'design' };
-  }
-
-  /**
-   * 确定 Skills（基于 Gate 和上下文）
-   */
-  private determineSkills(gate: Gate, context: JudgmentContext): string[] {
-    const baseSkills = (GATE_PROMPTS as Record<number, { skills: string[] }>)[gate]?.skills || ['arch'];
-
-    // 根据上下文调整 Skills
-    const { currentMessage } = context;
-    const lower = currentMessage.toLowerCase();
-
-    const skills = [...baseSkills];
-
-    // 如果涉及安全问题，添加 guardian-fixer
-    if (lower.includes('安全') || lower.includes('权限')) {
-      if (!skills.includes('guardian-fixer')) {
-        skills.push('guardian-fixer');
-      }
-    }
-
-    // 如果是复杂任务，添加 harness-eng
-    if (context.conversationHistory.length > 3) {
-      if (!skills.includes('harness-eng')) {
-        skills.push('harness-eng');
-      }
-    }
-
-    return skills;
-  }
-
-  /**
-   * 模式匹配（支持语义相似）
-   */
-  private matchesPattern(text: string, patterns: string[]): boolean {
-    return patterns.some(p => text.includes(p));
-  }
-
-  /**
-   * 生成 Harness 结果
-   */
-  private generateResult(gate: Gate, skills: string[]): string {
-    const results: Record<Gate, string> = {
-      0: '',
-      1: '建议采用分层架构：表现层、业务层、数据层分离',
-      2: '建议添加输入验证和错误处理',
-      3: '',
-      4: '建议实现 JWT token 过期和刷新机制',
-      5: '已分解为可执行的子任务',
-      6: '',
-      7: '建议使用策略模式重构业务逻辑',
-      8: '测试覆盖率目标 80%，优先测试核心业务'
-    };
-
-    return `[Gate ${gate}] ${results[gate] || 'Harness 分析完成'}`;
-  }
-
-  // ========================================
-  // 辅助方法
-  // ========================================
-
-  getGateHistory(): Gate[] {
-    return [...this.gateHistory];
-  }
-
-  getLastGate(): Gate {
-    return this.gateHistory.length > 0
-      ? this.gateHistory[this.gateHistory.length - 1]
-      : 0;
-  }
-
-  getLastDecision(): JudgmentResult | null {
-    return this.lastDecision;
-  }
-
-  generateNaturalResponse(): string[] {
-    return [
-      '好的，明白。',
-      '我理解了，继续。',
-      '没问题，我们继续。',
-      '明白，让我看看...',
-      '收到，我会处理的。',
-      '好的，这个信息很有用。'
-    ];
-  }
-
-  getGateResponses(gate: Gate): string[] {
-    const responses: Record<Gate, string[]> = {
-      1: [
-        '关于架构设计，Harness 分析建议采用分层架构。',
-        'Harness Gate 1 分析完成，建议使用依赖注入降低耦合。',
-      ],
-      2: [
-        '代码审查完成，Harness 建议添加输入验证。',
-        'Gate 2 审查结果：建议添加 JSDoc 注释。',
-      ],
-      4: [
-        '安全检查完成，建议实现 JWT token 过期机制。',
-        'Harness Gate 4 建议使用 HTTPS 加密传输。',
-      ],
-      5: [
-        '任务已分解为 4 个子任务。',
-        'Harness Gate 5 分解完成。',
-      ],
-      7: [
-        'Harness 建议使用策略模式重构。',
-        'Gate 7 分析：建议添加缓存机制。',
-      ],
-      8: [
-        '测试策略制定完成，目标覆盖率 80%。',
-        'Harness Gate 8：建议先写单元测试。',
-      ],
-      0: [],
-      3: [],
-      6: []
-    };
-    return responses[gate] || [];
-  }
-}
-
-// 单例
-let instance: ChannelJudgmentEngine | null = null;
-
-export function createChannelJudgmentEngine(options?: { useLLM?: boolean }): ChannelJudgmentEngine {
-  return new ChannelJudgmentEngine(options);
-}
-
-export function getChannelJudgmentEngine(): ChannelJudgmentEngine {
-  if (!instance) {
-    instance = new ChannelJudgmentEngine();
-  }
-  return instance;
-}