@bolloon/bolloon-agent 0.1.35 → 0.1.37

package/src/llm/llm-judgment-client.ts

@@ -1,470 +0,0 @@
-/**
- * LLM-as-Judge Client
- *
- * 集成 LLMConfigStore + PiAIModel + Prompt 配置
- * 实现真正的 LLM 原生判断力
- */
-
-import { llmConfigStore, type ModelProvider } from './config-store.js';
-import { PiAIModel, type ChatMessage } from './pi-ai.js';
-
-export interface JudgmentPromptConfig {
-  // 系统 Prompt
-  systemPrompt: string;
-
-  // 用户 Prompt 模板
-  userPromptTemplate: string;
-
-  // 输出格式
-  outputFormat: 'json' | 'structured' | 'free';
-
-  // 示例（few-shot）
-  examples?: Array<{
-    input: string;
-    output: string;
-  }>;
-}
-
-// 预定义的判断 Prompt 配置
-export const JUDGMENT_PROMPTS: Record<string, JudgmentPromptConfig> = {
-  // 默认判断 Prompt
-  default: {
-    systemPrompt: `你是一个专业的 AI 任务分析专家。你的职责是深入理解用户的问题，并给出精准的判断。
-
-核心原则：
-1. 第一性原理：追问问题的本质，而非表面现象
-2. 多角度思考：考虑不同视角和影响因素
-3. 上下文感知：理解对话历史和隐含意图
-4. 动态评估：根据实际情况判断复杂性
-
-你的判断会影响后续的智能体协作方式，请认真分析。`,
-
-    userPromptTemplate: `【当前输入】
-{user_input}
-
-【对话历史】
-{history}
-
-【发送者】
-{sender_name}
-
-请分析以上输入，判断：
-
-## 理解
-1. 问题本质是什么？（how-to / why / what / should / feasibility）
-2. 核心需求是什么？
-3. 有哪些隐含信息需要注意？
-
-## 评估
-1. 复杂性等级（simple / moderate / complex / profound）
-2. 为什么是这个等级？
-3. 需要多深的理解？（surface / deeper / fundamental）
-
-## 决策
-1. 推荐处理方式（answer / analyze / design / implement / coordinate）
-2. 为什么这样处理？
-
-## 路由
-1. 应该调用哪些 Skills？（arch / guardian-fixer / harness-eng / harness-dev / task-arch / crystal-learn）
-2. 需要什么协作模式？（solo / pair / team）
-
-请用 JSON 格式输出，格式如下：
-{
-  "understanding": {
-    "essence": "问题本质",
-    "coreNeed": "核心需求",
-    "implicit": ["隐含信息1", "隐含信息2"]
-  },
-  "assessment": {
-    "complexity": "complex",
-    "complexityReason": "评估理由",
-    "depth": "deeper"
-  },
-  "decision": {
-    "approach": "design",
-    "reasoning": "决策理由"
-  },
-  "routing": {
-    "skills": ["arch", "guardian-fixer"],
-    "collaboration": "pair"
-  }
-}`,
-
-    outputFormat: 'json'
-  },
-
-  // 架构相关问题
-  architecture: {
-    systemPrompt: `你是一个经验丰富的系统架构师。你擅长：
-- 从需求中提取本质问题
-- 设计可扩展的系统架构
-- 权衡技术方案
-- 识别架构风险
-
-你相信：
-- 本质和实现必须分离
-- 好的架构从简单规则中生长
-- 复杂性应该被控制而非消除`,
-
-    userPromptTemplate: `【架构设计问题】
-{user_input}
-
-【上下文】
-{context}
-
-请进行架构分析，判断是否需要 Harness 介入。
-
-分析维度：
-1. 涉及哪些架构维度？（分层、微服务、事件驱动等）
-2. 需要什么级别的架构设计？（概念性、逻辑性、物理性）
-3. 有什么架构风险需要考虑？
-
-输出 JSON：
-{
-  "needsHarness": true/false,
-  "gate": 0-8,
-  "skills": ["arch", "harness-eng"],
-  "architectureType": "microservices/layered/event-driven/etc",
-  "concerns": ["concern1", "concern2"]
-}`,
-
-    outputFormat: 'json'
-  },
-
-  // 代码相关问题
-  code: {
-    systemPrompt: `你是一个高效的代码实现专家。你擅长：
-- 快速理解和实现需求
-- 编写清晰、可维护的代码
-- 遵循最佳实践
-- 处理边界情况`,
-
-    userPromptTemplate: `【代码问题】
-{user_input}
-
-请判断这个问题：
-
-1. 是新功能实现还是修复问题？
-2. 涉及哪些代码层面？（业务逻辑、数据访问、接口设计）
-3. 需要什么测试覆盖？
-
-输出 JSON：
-{
-  "needsHarness": true/false,
-  "gate": 0-8,
-  "skills": ["harness-dev", "guardian-fixer"],
-  "codeType": "feature/fix/refactor",
-  "testCoverage": "unit/integration/e2e"
-}`,
-
-    outputFormat: 'json'
-  },
-
-  // 安全相关问题
-  security: {
-    systemPrompt: `你是一个严格的安全专家。你擅长：
-- 识别安全风险
-- 评估威胁模型
-- 设计安全方案
-- 遵循安全最佳实践`,
-
-    userPromptTemplate: `【安全问题】
-{user_input}
-
-请分析安全问题：
-
-1. 涉及哪些安全维度？（认证、授权、数据保护、传输安全）
-2. 风险等级？（低/中/高/严重）
-3. 需要什么安全措施？
-
-输出 JSON：
-{
-  "needsHarness": true,
-  "gate": 4,
-  "skills": ["guardian-fixer", "arch"],
-  "securityDimensions": ["authentication", "authorization"],
-  "riskLevel": "high",
-  "recommendations": ["rec1", "rec2"]
-}`,
-
-    outputFormat: 'json'
-  }
-};
-
-export interface LLMJudgmentResult {
-  // 理解
-  understanding: {
-    essence: string;
-    coreNeed: string;
-    implicit: string[];
-  };
-
-  // 评估
-  assessment: {
-    complexity: 'simple' | 'moderate' | 'complex' | 'profound';
-    complexityReason: string;
-    depth: 'surface' | 'deeper' | 'fundamental';
-  };
-
-  // 决策
-  decision: {
-    approach: 'answer' | 'analyze' | 'design' | 'implement' | 'coordinate';
-    reasoning: string;
-  };
-
-  // 路由
-  routing: {
-    skills: string[];
-    collaboration: 'solo' | 'pair' | 'team';
-  };
-
-  // 原始输出
-  raw?: string;
-}
-
-/**
- * LLM-as-Judge 客户端
- */
-export class LLMJudgmentClient {
-  private model: PiAIModel | null = null;
-  private useLLM: boolean = false;
-  private promptConfig: JudgmentPromptConfig = JUDGMENT_PROMPTS.default;
-
-  constructor(options?: {
-    provider?: ModelProvider;
-    useLLM?: boolean;
-    promptConfig?: string; // 配置名称
-  }) {
-    if (options?.promptConfig && JUDGMENT_PROMPTS[options.promptConfig]) {
-      this.promptConfig = JUDGMENT_PROMPTS[options.promptConfig];
-    }
-    this.useLLM = options?.useLLM ?? false;
-  }
-
-  /**
-   * 初始化 LLM 模型
-   */
-  async initialize(): Promise<void> {
-    if (this.useLLM) {
-      const config = await llmConfigStore.getActiveProviderConfig();
-      if (config && config.enabled) {
-        this.model = new PiAIModel({
-          provider: await llmConfigStore.getActiveProvider(),
-          apiKey: config.apiKey,
-          baseUrl: config.baseUrl,
-          model: config.model
-        });
-        console.log('[LLM-as-Judge] Initialized with LLM');
-      } else {
-        console.warn('[LLM-as-Judge] No LLM provider configured, using quick judgment');
-        this.useLLM = false;
-      }
-    }
-  }
-
-  /**
-   * 设置 Prompt 配置
-   */
-  setPromptConfig(configName: string): void {
-    if (JUDGMENT_PROMPTS[configName]) {
-      this.promptConfig = JUDGMENT_PROMPTS[configName];
-    }
-  }
-
-  /**
-   * 执行 LLM 判断
-   */
-  async judge(
-    userInput: string,
-    options?: {
-      history?: string[];
-      senderName?: string;
-      context?: string;
-    }
-  ): Promise<LLMJudgmentResult> {
-    // 构建 prompt
-    const historyStr = options?.history
-      ? options.history.slice(-5).map((m, i) => `[${i + 1}] ${m}`).join('\n')
-      : '无';
-
-    const userPrompt = this.promptConfig.userPromptTemplate
-      .replace('{user_input}', userInput)
-      .replace('{history}', historyStr)
-      .replace('{sender_name}', options?.senderName || 'Unknown')
-      .replace('{context}', options?.context || '无');
-
-    // 如果不使用 LLM 或模型未初始化，返回默认结果
-    if (!this.useLLM || !this.model) {
-      return this.quickJudgment(userInput);
-    }
-
-    try {
-      // 调用 LLM
-      const messages: ChatMessage[] = [
-        { role: 'system', content: this.promptConfig.systemPrompt },
-        { role: 'user', content: userPrompt }
-      ];
-
-      const response = await this.model.chat(userPrompt);
-
-      // 解析 JSON 输出
-      return this.parseResponse(response.reply);
-    } catch (error) {
-      console.error('[LLM-as-Judge] LLM call failed:', error);
-      return this.quickJudgment(userInput);
-    }
-  }
-
-  /**
-   * 解析 LLM 输出
-   */
-  private parseResponse(response: string): LLMJudgmentResult {
-    try {
-      // 尝试提取 JSON
-      const jsonMatch = response.match(/\{[\s\S]*\}/);
-      if (jsonMatch) {
-        const parsed = JSON.parse(jsonMatch[0]);
-        return {
-          understanding: {
-            essence: parsed.understanding?.essence || parsed.essence || 'unknown',
-            coreNeed: parsed.understanding?.coreNeed || parsed.coreNeed || 'unknown',
-            implicit: parsed.understanding?.implicit || parsed.implicit || []
-          },
-          assessment: {
-            complexity: this.normalizeComplexity(parsed.assessment?.complexity || parsed.complexity),
-            complexityReason: parsed.assessment?.complexityReason || parsed.complexityReason || '',
-            depth: this.normalizeDepth(parsed.assessment?.depth || parsed.depth)
-          },
-          decision: {
-            approach: this.normalizeApproach(parsed.decision?.approach || parsed.approach),
-            reasoning: parsed.decision?.reasoning || parsed.reasoning || ''
-          },
-          routing: {
-            skills: parsed.routing?.skills || parsed.skills || [],
-            collaboration: this.normalizeCollaboration(parsed.routing?.collaboration || parsed.collaboration)
-          },
-          raw: response
-        };
-      }
-    } catch (e) {
-      console.warn('[LLM-as-Judge] JSON parse failed, using fallback');
-    }
-
-    // 解析失败，返回默认结果
-    return this.quickJudgment(response);
-  }
-
-  /**
-   * 快速判断（fallback）
-   */
-  private quickJudgment(input: string): LLMJudgmentResult {
-    const lower = input.toLowerCase();
-
-    // 简化判断逻辑
-    let complexity: LLMJudgmentResult['assessment']['complexity'] = 'moderate';
-    let skills: string[] = [];
-    let collaboration: LLMJudgmentResult['routing']['collaboration'] = 'solo';
-
-    if (lower.includes('架构') || lower.includes('设计')) {
-      skills = ['arch'];
-      complexity = 'complex';
-      collaboration = 'pair';
-    }
-    if (lower.includes('review') || lower.includes('审查')) {
-      skills = ['guardian-fixer'];
-    }
-    if (lower.includes('安全') || lower.includes('权限')) {
-      skills = ['guardian-fixer', 'arch'];
-      complexity = 'complex';
-    }
-    if (lower.includes('任务') || lower.includes('分解')) {
-      skills = ['task-arch'];
-    }
-
-    return {
-      understanding: {
-        essence: this.extractEssence(lower),
-        coreNeed: this.extractCoreNeed(lower),
-        implicit: []
-      },
-      assessment: {
-        complexity,
-        complexityReason: '基于快速模式判断',
-        depth: 'surface'
-      },
-      decision: {
-        approach: skills.length > 0 ? 'analyze' : 'answer',
-        reasoning: '快速判断'
-      },
-      routing: {
-        skills,
-        collaboration
-      }
-    };
-  }
-
-  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 {
-    if (input.includes('设计') || input.includes('架构')) return '设计方案';
-    if (input.includes('实现') || input.includes('写')) return '实现代码';
-    if (input.includes('review') || input.includes('审查')) return '审查代码';
-    return '获得帮助';
-  }
-
-  private normalizeComplexity(c: string): LLMJudgmentResult['assessment']['complexity'] {
-    const lower = c.toLowerCase();
-    if (lower.includes('simple')) return 'simple';
-    if (lower.includes('moderate')) return 'moderate';
-    if (lower.includes('complex')) return 'complex';
-    return 'profound';
-  }
-
-  private normalizeDepth(d: string): LLMJudgmentResult['assessment']['depth'] {
-    const lower = d.toLowerCase();
-    if (lower.includes('surface')) return 'surface';
-    if (lower.includes('deeper')) return 'deeper';
-    return 'fundamental';
-  }
-
-  private normalizeApproach(a: string): LLMJudgmentResult['decision']['approach'] {
-    const lower = a.toLowerCase();
-    if (lower.includes('answer')) return 'answer';
-    if (lower.includes('analyze')) return 'analyze';
-    if (lower.includes('design')) return 'design';
-    if (lower.includes('implement')) return 'implement';
-    return 'coordinate';
-  }
-
-  private normalizeCollaboration(c: string): LLMJudgmentResult['routing']['collaboration'] {
-    const lower = c.toLowerCase();
-    if (lower.includes('solo')) return 'solo';
-    if (lower.includes('pair')) return 'pair';
-    return 'team';
-  }
-}
-
-// 工厂函数
-export function createLLMJudgmentClient(options?: {
-  provider?: ModelProvider;
-  useLLM?: boolean;
-  promptConfig?: string;
-}): LLMJudgmentClient {
-  return new LLMJudgmentClient(options);
-}
-
-// 默认实例
-let defaultClient: LLMJudgmentClient | null = null;
-
-export async function getDefaultJudgmentClient(): Promise<LLMJudgmentClient> {
-  if (!defaultClient) {
-    defaultClient = createLLMJudgmentClient({ useLLM: true });
-    await defaultClient.initialize();
-  }
-  return defaultClient;
-}