@bolloon/bolloon-agent 0.1.0

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

@@ -0,0 +1,712 @@
+/**
+ * LLM-native Judgment Engine
+ *
+ * 核心理念：
+ * - 不使用关键词匹配，而是让 LLM 理解用户意图
+ * - 价值观注入：学习人类判断价值观，注入到 Prompt 中
+ * - Skills 可以被动态调用
+ *
+ * 架构：
+ * 1. LLM-as-Judge: 使用 LLM 执行真正的理解
+ * 2. Value Injection: 从 human-value-store 获取价值观注入
+ * 3. Dynamic-Skill-Routing: 根据判断结果动态调用 Skills
+ */
+
+import { createBollharnessIntegration } from './integration.js';
+import {
+  generateJudgmentPromptWithValues,
+  type ValueInjectionConfig
+} from '../pi-ecosystem-judgment/value-injection.js';
+import {
+  learnFromFeedback,
+  learnFromCorrection
+} from '../pi-ecosystem-judgment/human-value-store.js';
+import { initPiAI, getModel, isModelAvailable } from '../llm/pi-ai.js';
+import { getPiSDKConfig } from '../llm/config-store.js';
+
+export interface LLMJudgmentResult {
+  // 理解结果
+  understanding: {
+    essence: string;           // 问题本质
+    coreNeed: string;          // 核心需求
+    implicit: string[];        // 隐含信息
+  };
+
+  // 评估结果
+  assessment: {
+    complexity: 'simple' | 'moderate' | 'complex' | 'profound';
+    complexityReason: string;   // 为什么是这个复杂性
+    depth: 'surface' | 'deeper' | 'fundamental';
+    urgency: 'low' | 'medium' | 'high' | 'critical';
+  };
+
+  // 决策
+  decision: {
+    approach: 'answer' | 'analyze' | 'design' | 'implement' | 'coordinate';
+    reasoning: string;          // 决策理由
+  };
+
+  // 路由
+  routing: {
+    skills: string[];          // 应该调用的 Skills
+    agents: string[];          // 应该参与的智能体
+    collaboration: 'solo' | 'pair' | 'team';
+  };
+
+  // 产物
+  artifacts: {
+    required: string[];        // 需要什么产物
+    gate?: number;            // 如果需要 gate
+  };
+
+  // 原始 LLM 输出
+  raw?: string;
+}
+
+/**
+ * 判断用的 Prompt 模板（可以从 YAML 加载）
+ */
+export const JUDGMENT_PROMPT_TEMPLATE = `你是一个专业的 AI 任务分析专家。你的职责是深入理解用户的问题，并给出精准的判断。
+
+【输入】
+{user_input}
+
+【历史上下文】
+{history_context}
+
+请分析以上输入，回答以下问题：
+
+## 1. 问题理解
+
+**问题本质**：用户真正想要什么？这是什么类型的问题？
+- how-to: 寻求操作指导
+- why: 寻求解释
+- what: 寻求定义
+- should: 寻求建议
+- feasibility: 寻求可行性评估
+
+**核心需求**：用户最想要的结果是什么？
+
+**隐含信息**：有什么用户没有明确说但需要考虑的因素？
+- 时间压力？
+- 质量要求？
+- 风险限制？
+- 团队协作？
+
+## 2. 复杂性评估
+
+**复杂性等级**：这个问题有多复杂？
+- simple: 简单任务，直接可答
+- moderate: 中等复杂，需要一定思考
+- complex: 复杂问题，需要深入分析
+- profound: 深刻问题，需要本质性思考
+
+**评估理由**：为什么认为这是这个复杂性等级？
+
+**深度**：需要多深的理解？
+- surface: 表面理解即可
+- deeper: 需要分析
+- fundamental: 需要本质性思考
+
+## 3. 处理决策
+
+**推荐方式**：
+- answer: 直接回答
+- analyze: 深入分析
+- design: 设计方案
+- implement: 实现代码
+- coordinate: 协调多智能体
+
+**决策理由**：为什么推荐这个处理方式？
+
+## 4. 路由决策
+
+**应该调用的 Skills**（可选多个）：
+- arch: 架构设计
+- harness-dev: 开发实现
+- guardian-fixer: 代码审查
+- harness-eng: 工程协调
+- harness-eng-test: 测试工程
+- task-arch: 任务分解
+- crystal-learn: 反思学习
+
+**参与智能体**（可选）：
+- architect: 架构师
+- developer: 开发者
+- reviewer: 审查员
+- coordinator: 协调者
+
+**协作模式**：
+- solo: 单独处理
+- pair: 配对协作
+- team: 团队协作
+
+## 5. 产出要求
+
+**需要的产物**：
+- 问题分析
+- 方案设计
+- 代码实现
+- 测试用例
+- 其他
+
+**Gate 建议**（如果有）：
+- Gate 0: 问题锁定
+- Gate 1: 架构设计
+- Gate 2: 架构审查
+- Gate 3: 计划制定
+- Gate 4: 计划审查
+- Gate 5: 任务分解
+- Gate 6: 任务审查
+- Gate 7: 代码实现
+- Gate 8: 测试验证
+
+请用 JSON 格式输出分析结果。`;
+
+/**
+ * 简化的判断结果（用于快速场景）
+ */
+export interface QuickJudgment {
+  complexity: 'simple' | 'moderate' | 'complex' | 'profound';
+  approach: 'answer' | 'analyze' | 'design' | 'implement' | 'coordinate';
+  skills: string[];
+  collaboration: 'solo' | 'pair' | 'team';
+}
+
+/**
+ * LLM-native Judgment Engine
+ */
+export class LLMJudgmentEngine {
+  private harness: ReturnType<typeof createBollharnessIntegration>;
+  private promptTemplate: string;
+  private useLLM: boolean;
+  private valueInjectionConfig: Partial<ValueInjectionConfig>;
+  private recentJudgments: Array<{
+    input: string;
+    result: LLMJudgmentResult;
+    timestamp: number;
+  }> = [];
+
+  constructor(options?: {
+    useLLM?: boolean;
+    promptTemplate?: string;
+    valueInjectionConfig?: Partial<ValueInjectionConfig>;
+  }) {
+    this.harness = createBollharnessIntegration();
+    this.promptTemplate = options?.promptTemplate || JUDGMENT_PROMPT_TEMPLATE;
+    this.useLLM = options?.useLLM ?? true;
+    this.valueInjectionConfig = options?.valueInjectionConfig || {};
+  }
+
+  /**
+   * 设置判断用的 Prompt 模板
+   */
+  setPromptTemplate(template: string): void {
+    this.promptTemplate = template;
+  }
+
+  /**
+   * 设置价值观注入配置
+   */
+  setValueInjectionConfig(config: Partial<ValueInjectionConfig>): void {
+    this.valueInjectionConfig = config;
+  }
+
+  /**
+   * 从配置文件加载 Prompt
+   */
+  async loadPromptFromConfig(configPath: string): Promise<void> {
+    // TODO: 从 YAML/JSON 加载 prompt 模板
+    // 这个配置可以包含更复杂的 prompt 变体
+  }
+
+  /**
+   * 执行 LLM 判断（集成价值观注入）
+   */
+  async judge(
+    userInput: string,
+    options?: {
+      history?: string[];
+      forceLLM?: boolean;
+      context?: string;
+    }
+  ): Promise<LLMJudgmentResult> {
+    // 如果强制不使用 LLM 或未配置，使用简化判断
+    if (!this.useLLM && !options?.forceLLM) {
+      return this.quickJudge(userInput);
+    }
+
+    // 构建 prompt（带价值观注入）
+    const historyContext = options?.history
+      ? options.history.slice(-5).join('\n')
+      : '无历史上下文';
+
+    const context = options?.context || userInput;
+
+    // 生成带价值观的 prompt
+    let prompt: string;
+    try {
+      prompt = await generateJudgmentPromptWithValues(
+        userInput,
+        context,
+        options?.history || [],
+        this.valueInjectionConfig
+      );
+    } catch (error) {
+      // 价值观注入失败，使用基础 prompt
+      console.warn('[LLMJudgment] Value injection failed, using base prompt:', error);
+      prompt = this.promptTemplate
+        .replace('{user_input}', userInput)
+        .replace('{history_context}', historyContext);
+    }
+
+    try {
+      // 调用 LLM（这里需要集成 LLMConfigStore）
+      const result = await this.callLLM(prompt);
+
+      // 解析 LLM 输出
+      const judgmentResult = this.parseLLMOutput(result, userInput);
+
+      // 记录判断结果（用于学习）
+      this.recordJudgment(userInput, judgmentResult);
+
+      return judgmentResult;
+    } catch (error) {
+      console.warn('[LLMJudgment] LLM call failed, falling back to quick judgment:', error);
+      return this.quickJudge(userInput);
+    }
+  }
+
+  /**
+   * 记录判断结果（支持后续学习）
+   */
+  private recordJudgment(input: string, result: LLMJudgmentResult): void {
+    this.recentJudgments.push({
+      input,
+      result,
+      timestamp: Date.now()
+    });
+
+    // 保留最近 50 条判断
+    if (this.recentJudgments.length > 50) {
+      this.recentJudgments.shift();
+    }
+  }
+
+  /**
+   * 学习人类反馈（集成到判断引擎）
+   */
+  async learnFromHumanFeedback(
+    originalInput: string,
+    approved: boolean,
+    reason?: string
+  ): Promise<void> {
+    // 从反馈中学习
+    await learnFromFeedback(originalInput, approved, reason);
+
+    // 重新评估相关判断的置信度
+    const relatedJudgment = this.recentJudgments.find(
+      j => j.input.includes(originalInput.substring(0, 20))
+    );
+
+    if (relatedJudgment && !approved) {
+      // 如果被拒绝，降低置信度
+      console.log('[LLMJudgment] Learning from rejection, will adjust future judgments');
+    }
+  }
+
+  /**
+   * 学习修正（从错误中学习）
+   */
+  async learnFromCorrection(original: string, corrected: string, reason: string): Promise<void> {
+    await learnFromCorrection(original, corrected, reason);
+  }
+
+  /**
+   * 调用 LLM
+   */
+  private async callLLM(prompt: string): Promise<string> {
+    if (!isModelAvailable()) {
+      const config = getPiSDKConfig();
+      initPiAI(config);
+    }
+
+    const model = getModel();
+    const result = await model.chat(prompt, process.cwd());
+    return result.reply;
+  }
+
+  /**
+   * 解析 LLM 输出
+   */
+  private parseLLMOutput(output: string, originalInput: string): LLMJudgmentResult {
+    try {
+      // 尝试解析 JSON
+      const parsed = JSON.parse(output);
+
+      return {
+        understanding: {
+          essence: parsed.essence || parsed.问题本质 || 'unknown',
+          coreNeed: parsed.coreNeed || parsed.核心需求 || 'unknown',
+          implicit: parsed.implicit || parsed.隐含信息 || []
+        },
+        assessment: {
+          complexity: this.normalizeComplexity(parsed.complexity || parsed.复杂性等级),
+          complexityReason: parsed.complexityReason || parsed.评估理由 || '',
+          depth: this.normalizeDepth(parsed.depth || parsed.深度),
+          urgency: this.normalizeUrgency(parsed.urgency || 'medium')
+        },
+        decision: {
+          approach: this.normalizeApproach(parsed.approach || parsed.推荐方式),
+          reasoning: parsed.reasoning || parsed.决策理由 || ''
+        },
+        routing: {
+          skills: parsed.skills || parsed.应该调用的Skills || [],
+          agents: parsed.agents || parsed.参与智能体 || [],
+          collaboration: this.normalizeCollaboration(parsed.collaboration || parsed.协作模式)
+        },
+        artifacts: {
+          required: parsed.artifacts || parsed.需要的产物 || [],
+          gate: parsed.gate || parsed.Gate建议
+        },
+        raw: output
+      };
+    } catch {
+      // JSON 解析失败，返回默认结果
+      return this.quickJudge(originalInput);
+    }
+  }
+
+  /**
+   * 快速判断（不调用 LLM）
+   */
+  private quickJudge(userInput: string): LLMJudgmentResult {
+    const input = userInput.toLowerCase();
+    const words = userInput.length;
+
+    // 复杂性评估
+    let complexity: 'simple' | 'moderate' | 'complex' | 'profound' = 'moderate';
+    let complexityReason = '';
+
+    const hasDesignKeywords = input.includes('设计') || input.includes('架构');
+    const hasReviewKeywords = input.includes('review') || input.includes('审查');
+    const hasMultiSystem = input.includes('和') || input.includes('以及');
+    const hasFundamental = input.includes('为什么') || input.includes('本质') || input.includes('根本');
+
+    if (hasDesignKeywords || hasMultiSystem || words > 200) {
+      complexity = 'complex';
+      complexityReason = '涉及设计或多系统';
+    }
+    if (hasFundamental || (words > 500 && hasDesignKeywords)) {
+      complexity = 'profound';
+      complexityReason = '需要本质性思考';
+    }
+    if (words < 50 && !hasDesignKeywords) {
+      complexity = 'simple';
+      complexityReason = '简短输入，意图明确';
+    }
+
+    // 处理方式
+    let approach: LLMJudgmentResult['decision']['approach'] = 'answer';
+    if (hasDesignKeywords) approach = 'design';
+    else if (hasReviewKeywords || input.includes('分析')) approach = 'analyze';
+    else if (input.includes('实现') || input.includes('写')) approach = 'implement';
+
+    // Skills
+    const skills: string[] = [];
+    if (hasDesignKeywords) skills.push('arch');
+    if (hasReviewKeywords) skills.push('guardian-fixer');
+    if (approach === 'implement') skills.push('harness-dev');
+    if (complexity === 'complex' || complexity === 'profound') {
+      skills.push('harness-eng');
+    }
+
+    // 协作模式
+    const collaboration: LLMJudgmentResult['routing']['collaboration'] =
+      complexity === 'profound' ? 'team' :
+      complexity === 'complex' ? 'pair' : 'solo';
+
+    return {
+      understanding: {
+        essence: this.extractEssence(input),
+        coreNeed: this.extractCoreNeed(input),
+        implicit: []
+      },
+      assessment: {
+        complexity,
+        complexityReason,
+        depth: hasFundamental ? 'fundamental' : 'surface',
+        urgency: input.includes('紧急') ? 'high' : 'medium'
+      },
+      decision: {
+        approach,
+        reasoning: '基于快速模式判断'
+      },
+      routing: {
+        skills,
+        agents: [],
+        collaboration
+      },
+      artifacts: {
+        required: approach === 'design' ? ['架构文档'] : ['回答']
+      }
+    };
+  }
+
+  private normalizeComplexity(c: string): LLMJudgmentResult['assessment']['complexity'] {
+    const lower = c.toLowerCase();
+    if (lower.includes('simple') || lower.includes('简单')) return 'simple';
+    if (lower.includes('moderate') || lower.includes('中等')) return 'moderate';
+    if (lower.includes('complex') || lower.includes('复杂')) return 'complex';
+    return 'profound';
+  }
+
+  private normalizeDepth(d: string): LLMJudgmentResult['assessment']['depth'] {
+    const lower = d.toLowerCase();
+    if (lower.includes('surface') || lower.includes('表面')) return 'surface';
+    if (lower.includes('deeper') || lower.includes('深入')) return 'deeper';
+    return 'fundamental';
+  }
+
+  private normalizeUrgency(u: string): LLMJudgmentResult['assessment']['urgency'] {
+    const lower = u.toLowerCase();
+    if (lower.includes('low') || lower.includes('低')) return 'low';
+    if (lower.includes('high') || lower.includes('高') || lower.includes('紧急')) return 'high';
+    if (lower.includes('critical') || lower.includes('关键')) return 'critical';
+    return 'medium';
+  }
+
+  private normalizeApproach(a: string): LLMJudgmentResult['decision']['approach'] {
+    const lower = a.toLowerCase();
+    if (lower.includes('answer') || lower.includes('回答')) return 'answer';
+    if (lower.includes('analyze') || lower.includes('分析')) return 'analyze';
+    if (lower.includes('design') || lower.includes('设计')) return 'design';
+    if (lower.includes('implement') || lower.includes('实现')) return 'implement';
+    return 'coordinate';
+  }
+
+  private normalizeCollaboration(c: string): LLMJudgmentResult['routing']['collaboration'] {
+    const lower = c.toLowerCase();
+    if (lower.includes('solo') || lower.includes('单独')) return 'solo';
+    if (lower.includes('pair') || lower.includes('配对')) return 'pair';
+    return 'team';
+  }
+
+  private extractEssence(input: string): string {
+    if (input.includes('为什么')) return 'why: 寻求解释';
+    if (input.includes('怎么') || input.includes('如何')) return 'how-to: 寻求指导';
+    if (input.includes('应该')) return 'should: 寻求建议';
+    return 'general: 一般性讨论';
+  }
+
+  private extractCoreNeed(input: string): string {
+    const lower = input.toLowerCase();
+    if (lower.includes('设计') || lower.includes('架构')) return '设计方案';
+    if (lower.includes('实现') || lower.includes('写')) return '实现代码';
+    if (lower.includes('修复') || lower.includes('解决')) return '修复问题';
+    if (lower.includes('review') || lower.includes('审查')) return '审查代码';
+    return '获得帮助';
+  }
+}
+
+// 单例
+let engineInstance: LLMJudgmentEngine | null = null;
+
+export function createLLMJudgmentEngine(options?: {
+  useLLM?: boolean;
+  promptTemplate?: string;
+}): LLMJudgmentEngine {
+  return new LLMJudgmentEngine(options);
+}
+
+export function getLLMJudgmentEngine(): LLMJudgmentEngine {
+  if (!engineInstance) {
+    engineInstance = new LLMJudgmentEngine();
+  }
+  return engineInstance;
+}
+
+/**
+ * Skill Prompt 配置（可以从 YAML 加载）
+ */
+export interface SkillPromptConfig {
+  name: string;
+  description: string;
+  systemPrompt: string;        // 系统级 prompt
+  userPromptTemplate: string;  // 用户输入的 prompt 模板
+  examples?: Array<{
+    input: string;
+    output: string;
+  }>;
+  constraints?: string[];
+  outputFormat?: string;
+}
+
+/**
+ * Skills 的 Prompt 配置
+ */
+export const SKILL_PROMPTS: Record<string, SkillPromptConfig> = {
+  arch: {
+    name: 'arch',
+    description: '架构设计专家',
+    systemPrompt: `你是一个经验丰富的系统架构师。你擅长：
+- 从需求中提取本质问题
+- 设计可扩展的系统架构
+- 权衡技术方案
+- 识别架构风险
+
+你相信：
+- 本质和实现必须分离
+- 好的架构从简单规则中生长
+- 复杂性应该被控制而非消除`,
+    userPromptTemplate: `用户需求：{user_input}
+
+{context}
+
+请进行架构分析：`,
+    examples: [
+      {
+        input: '设计一个电商系统',
+        output: '我将首先分析电商系统的核心本质：交易撮合...'
+      }
+    ],
+    outputFormat: 'markdown'
+  },
+
+  'harness-dev': {
+    name: 'harness-dev',
+    description: '开发实现专家',
+    systemPrompt: `你是一个高效的代码实现专家。你擅长：
+- 快速理解和实现需求
+- 编写清晰、可维护的代码
+- 遵循最佳实践
+- 处理边界情况
+
+你相信：
+- 代码即文档
+- 测试是代码的一部分
+- 简单优于复杂`,
+    userPromptTemplate: `任务：{user_input}
+
+技术栈：{tech_stack}
+
+请实现代码：`,
+    outputFormat: 'code'
+  },
+
+  'guardian-fixer': {
+    name: 'guardian-fixer',
+    description: '代码审查专家',
+    systemPrompt: `你是一个严格的代码审查专家。你擅长：
+- 发现潜在问题
+- 提出改进建议
+- 确保代码质量
+- 平衡效率和安全性
+
+你相信：
+- 细节决定成败
+- 代码审查是质量保障的最后防线
+- 建设性批评比否定更有价值`,
+    userPromptTemplate: `代码：\n{code}
+
+审查范围：{scope}
+
+请进行审查：`,
+    outputFormat: 'structured'
+  }
+};
+
+/**
+ * 动态 Skill 调用器
+ */
+export class DynamicSkillRouter {
+  private skillPrompts: Record<string, SkillPromptConfig>;
+  private judgmentEngine: LLMJudgmentEngine;
+
+  constructor(options?: { useLLM?: boolean }) {
+    this.skillPrompts = SKILL_PROMPTS;
+    this.judgmentEngine = createLLMJudgmentEngine({ useLLM: options?.useLLM ?? true });
+  }
+
+  /**
+   * 根据判断结果动态调用 Skills
+   */
+  async routeAndExecute(
+    userInput: string,
+    judgment: LLMJudgmentResult,
+    context?: Record<string, unknown>
+  ): Promise<Record<string, unknown>> {
+    const results: Record<string, unknown> = {};
+
+    // 并行执行多个 Skills
+    const skillPromises = judgment.routing.skills.map(async (skillName) => {
+      const skillConfig = this.skillPrompts[skillName];
+      if (!skillConfig) {
+        console.warn(`[SkillRouter] Unknown skill: ${skillName}`);
+        return { skill: skillName, result: null };
+      }
+
+      try {
+        const result = await this.executeSkill(
+          skillConfig,
+          userInput,
+          context
+        );
+        return { skill: skillName, result };
+      } catch (error) {
+        console.error(`[SkillRouter] Skill ${skillName} failed:`, error);
+        return { skill: skillName, result: null, error };
+      }
+    });
+
+    const skillResults = await Promise.all(skillPromises);
+
+    for (const { skill, result, error } of skillResults) {
+      results[skill] = result || { error: String(error) };
+    }
+
+    return results;
+  }
+
+  /**
+   * 执行单个 Skill
+   */
+  private async executeSkill(
+    skillConfig: SkillPromptConfig,
+    userInput: string,
+    context?: Record<string, unknown>
+  ): Promise<string> {
+    // 构建 prompt
+    let prompt = skillConfig.userPromptTemplate.replace('{user_input}', userInput);
+
+    if (context) {
+      for (const [key, value] of Object.entries(context)) {
+        prompt = prompt.replace(`{${key}}`, String(value));
+      }
+    }
+
+    // TODO: 调用 LLM 执行 Skill
+    // 这里需要集成实际的 LLM 调用
+
+    return `Skill ${skillConfig.name} executed with prompt:\n${prompt}`;
+  }
+
+  /**
+   * 添加自定义 Skill
+   */
+  registerSkill(name: string, config: SkillPromptConfig): void {
+    this.skillPrompts[name] = config;
+  }
+
+  /**
+   * 获取可用的 Skills
+   */
+  listSkills(): string[] {
+    return Object.keys(this.skillPrompts);
+  }
+}
+
+// 导出工厂函数
+export function createDynamicSkillRouter(options?: { useLLM?: boolean }): DynamicSkillRouter {
+  return new DynamicSkillRouter(options);
+}