autosnippet 3.0.11 → 3.0.13

package/lib/service/chat/ChatAgent.js

@@ -31,6 +31,18 @@ import { ConversationStore } from './ConversationStore.js';
 import { Memory } from './Memory.js';
 import { ReasoningLayer } from './ReasoningLayer.js';
 import { TaskPipeline } from './TaskPipeline.js';
+import {
+  taskCheckAndSubmit,
+  taskDiscoverAllRelations,
+  taskFullEnrich,
+  taskQualityAudit,
+  taskGuardFullScan,
+} from './ChatAgentTasks.js';
+import {
+  buildNativeToolSystemPrompt,
+  buildProjectBriefing,
+  cleanFinalAnswer,
+} from './ChatAgentPrompts.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = path.resolve(__dirname, '../../..');
@@ -245,7 +257,7 @@ export class ChatAgent {
     }
 
     // 每次对话刷新项目概况（不是每轮 ReAct）
-    this.#projectBriefingCache = await this.#buildProjectBriefing();
+    this.#projectBriefingCache = await buildProjectBriefing({ container: this.#container });
 
     // ── 统一原生函数调用路径（v5.0: 移除文本解析路径） ──
     // 所有 Provider 均通过 chatWithTools() 进行结构化工具调用。
@@ -408,7 +420,14 @@ export class ChatAgent {
       isSystem && !disablePhaseRouter ? new PhaseRouter(budget, isSkillOnly) : null;
 
     // ── 系统提示词 (支持外部覆盖) ──
-    let baseSystemPrompt = systemPromptOverride || this.#buildNativeToolSystemPrompt(budget);
+    let baseSystemPrompt = systemPromptOverride || buildNativeToolSystemPrompt({
+      currentSource: this.#currentSource,
+      projectBriefingCache: this.#projectBriefingCache,
+      memory: this.#memory,
+      semanticMemory: this.#semanticMemory,
+      budget,
+      soulPath: SOUL_PATH,
+    });
 
     // ── 统一注入语言指令（对所有来源生效: user 对话 / system bootstrap / analyst / producer）──
     const effectiveLang = this.#currentLang;
@@ -734,7 +753,7 @@ export class ChatAgent {
             `[ChatAgent] ⚠ AI returned ${aiResult.functionCalls.length} tool calls despite toolChoice=none (graceful exit) — ignoring tools, treating as text`
           );
           if (aiResult.text) {
-            const reply = this.#cleanFinalAnswer(aiResult.text);
+            const reply = cleanFinalAnswer(aiResult.text);
             const totalDuration = Date.now() - execStartTime;
             reasoning.afterRound();
             this.#logger.info(
@@ -1095,7 +1114,7 @@ export class ChatAgent {
             continue;
           }
           // 已在 SUMMARIZE 阶段 — 这就是最终回答
-          const reply = this.#cleanFinalAnswer(aiResult.text || '');
+          const reply = cleanFinalAnswer(aiResult.text || '');
           const totalDuration = Date.now() - execStartTime;
           reasoning.afterRound();
           this.#logger.info(
@@ -1126,7 +1145,7 @@ export class ChatAgent {
             continue;
           }
           // 非生产阶段的未转换文本 = 最终回答
-          const reply = this.#cleanFinalAnswer(aiResult.text || '');
+          const reply = cleanFinalAnswer(aiResult.text || '');
           const totalDuration = Date.now() - execStartTime;
           reasoning.afterRound();
           this.#logger.info(
@@ -1148,7 +1167,7 @@ export class ChatAgent {
 
       // 用户对话 / graceful exit: 文字回答即最终回答
       if (ctx.__gracefulExitInjected || !isSystem) {
-        const reply = this.#cleanFinalAnswer(aiResult.text || '');
+        const reply = cleanFinalAnswer(aiResult.text || '');
         const totalDuration = Date.now() - execStartTime;
         reasoning.afterRound();
         this.#logger.info(
@@ -1164,7 +1183,7 @@ export class ChatAgent {
       }
 
       // system 模式非 graceful exit 的文字回答（理论上不应到这里）
-      const reply = this.#cleanFinalAnswer(aiResult.text || '');
+      const reply = cleanFinalAnswer(aiResult.text || '');
       const totalDuration = Date.now() - execStartTime;
       reasoning.afterRound();
       this.#logger.info(
@@ -1299,7 +1318,7 @@ ${toolContextSummary}
         this.#currentTokenUsage.input += summaryResult.usage.inputTokens || 0;
         this.#currentTokenUsage.output += summaryResult.usage.outputTokens || 0;
       }
-      finalReply = this.#cleanFinalAnswer(summaryResult.text || '');
+      finalReply = cleanFinalAnswer(summaryResult.text || '');
     } catch (err) {
       this.#logger.warn(`[ChatAgent] forced summary AI call failed: ${err.message}`);
 
@@ -1514,18 +1533,25 @@ ${toolContextSummary}
     if (this.#pipelines.has(taskName)) {
       return this.runPipeline(taskName, params);
     }
+    // 构建任务上下文（提供给外部任务函数）
+    const taskContext = {
+      executeTool: (name, p) => this.executeTool(name, p),
+      aiProvider: this.#aiProvider,
+      container: this.#container,
+      logger: this.#logger,
+    };
     // 降级到硬编码任务（复杂交互逻辑无法用 DAG 表达的场景）
     switch (taskName) {
       case 'check_and_submit':
-        return this.#taskCheckAndSubmit(params);
+        return taskCheckAndSubmit(taskContext, params);
       case 'discover_all_relations':
-        return this.#taskDiscoverAllRelations(params);
+        return taskDiscoverAllRelations(taskContext, params);
       case 'full_enrich':
-        return this.#taskFullEnrich(params);
+        return taskFullEnrich(taskContext, params);
       case 'quality_audit':
-        return this.#taskQualityAudit(params);
+        return taskQualityAudit(taskContext, params);
       case 'guard_full_scan':
-        return this.#taskGuardFullScan(params);
+        return taskGuardFullScan(taskContext, params);
       default:
         throw new Error(`Unknown task: ${taskName}`);
     }
@@ -1589,289 +1615,6 @@ ${toolContextSummary}
     };
   }
 
-  // ─── 预定义任务 ────────────────────────────────────────
-
-  /**
-   * 任务: 提交前查重 + 质量预评
-   * 1. check_duplicate → 若发现相似 ≥ 0.7 则建议合并
-   * 2. 顺便返回质量评估建议
-   */
-  async #taskCheckAndSubmit({ candidate, projectRoot }) {
-    // Step 1: 查重
-    const duplicates = await this.executeTool('check_duplicate', {
-      candidate,
-      projectRoot,
-      threshold: 0.5,
-    });
-
-    // Step 2: 如果有高相似度，使用 AI 分析是否真正重复
-    const highSim = (duplicates.similar || []).filter((d) => d.similarity >= 0.7);
-    let aiVerdict = null;
-    if (highSim.length > 0 && this.#aiProvider) {
-      const verdictPrompt = `以下新候选代码与已有 Recipe 高度相似，请判断是否真正重复。
-
-新候选:
-- Title: ${candidate.title || '(未命名)'}
-- Code: ${(candidate.code || '').substring(0, 1000)}
-
-相似 Recipe:
-${highSim.map((s) => `- ${s.title} (相似度: ${s.similarity})`).join('\n')}
-
-请回答: DUPLICATE（真正重复）/ SIMILAR（相似但不同，建议保留并标注关系）/ UNIQUE（误判，可放心提交）
-只回答一个词。`;
-      try {
-        const raw = await this.#aiProvider.chat(verdictPrompt, { temperature: 0, maxTokens: 20 });
-        aiVerdict = (raw || '').trim().toUpperCase().split(/\s/)[0];
-      } catch {
-        /* ignore */
-      }
-    }
-
-    return {
-      duplicates: duplicates.similar || [],
-      highSimilarity: highSim,
-      aiVerdict,
-      recommendation:
-        highSim.length === 0
-          ? 'safe_to_submit'
-          : aiVerdict === 'DUPLICATE'
-            ? 'block_duplicate'
-            : 'review_suggested',
-    };
-  }
-
-  /**
-   * 任务: 批量发现 Recipe 间的知识图谱关系
-   * 遍历所有 Recipe，两两分析可能的关系
-   */
-  async #taskDiscoverAllRelations({ batchSize = 20 } = {}) {
-    const ctx = this.#getToolContext();
-    const knowledgeService = ctx.container.get('knowledgeService');
-    if (!knowledgeService) {
-      throw new Error('KnowledgeService 不可用');
-    }
-
-    if (!ctx.aiProvider) {
-      throw new Error('AI Provider 未配置，请先设置 API Key');
-    }
-
-    // 获取所有活跃知识条目
-    const { items = [], data = [] } = await knowledgeService.list(
-      { lifecycle: 'active' },
-      { page: 1, pageSize: 500 }
-    );
-    const recipes = items.length > 0 ? items : data;
-    if (recipes.length < 2) {
-      return {
-        discovered: 0,
-        totalPairs: 0,
-        message: `只有 ${recipes.length} 条 Recipe，至少需要 2 条`,
-      };
-    }
-
-    // 按 batch 分组分析
-    const pairs = [];
-    for (let i = 0; i < recipes.length; i++) {
-      for (let j = i + 1; j < recipes.length; j++) {
-        pairs.push([recipes[i], recipes[j]]);
-      }
-    }
-
-    let discovered = 0;
-    const results = [];
-    let batchErrors = 0;
-
-    // 分批处理，单批失败不终止整体
-    for (let b = 0; b < pairs.length; b += batchSize) {
-      const batch = pairs.slice(b, b + batchSize);
-      try {
-        const result = await this.executeTool('discover_relations', {
-          recipePairs: batch.map(([a, b]) => ({
-            a: {
-              id: a.id,
-              title: a.title,
-              category: a.category,
-              language: a.language,
-              code: String(a.content || a.code || '').substring(0, 500),
-            },
-            b: {
-              id: b.id,
-              title: b.title,
-              category: b.category,
-              language: b.language,
-              code: String(b.content || b.code || '').substring(0, 500),
-            },
-          })),
-        });
-
-        if (result.error) {
-          batchErrors++;
-          this.#logger.warn(
-            `[DiscoverRelations] Batch ${Math.floor(b / batchSize) + 1} error: ${result.error}`
-          );
-          continue;
-        }
-        if (result.relations) {
-          discovered += result.relations.length;
-          results.push(...result.relations);
-        }
-      } catch (err) {
-        batchErrors++;
-        this.#logger.warn(
-          `[DiscoverRelations] Batch ${Math.floor(b / batchSize) + 1} threw: ${err.message}`
-        );
-      }
-    }
-
-    return {
-      discovered,
-      totalPairs: pairs.length,
-      totalBatches: Math.ceil(pairs.length / batchSize),
-      batchErrors,
-      relations: results,
-    };
-  }
-
-  /**
-   * 任务: 批量 AI 补全候选语义字段
-   */
-  async #taskFullEnrich({ status = 'pending', maxCount = 50 } = {}) {
-    const ctx = this.#getToolContext();
-    const knowledgeService = ctx.container.get('knowledgeService');
-
-    const { items = [], data = [] } = await knowledgeService.list(
-      { lifecycle: status },
-      { page: 1, pageSize: maxCount }
-    );
-    const candidates = items.length > 0 ? items : data;
-    if (candidates.length === 0) {
-      return { enriched: 0, message: 'No candidates to enrich' };
-    }
-
-    // 筛选缺失语义字段的候选
-    const needEnrich = candidates.filter((c) => {
-      const m = c.metadata || {};
-      return !m.rationale || !m.knowledgeType || !m.complexity;
-    });
-
-    if (needEnrich.length === 0) {
-      return { enriched: 0, message: 'All candidates already enriched' };
-    }
-
-    const result = await this.executeTool('enrich_candidate', {
-      candidateIds: needEnrich.map((c) => c.id).slice(0, 20),
-    });
-
-    return result;
-  }
-
-  /**
-   * 任务: 批量质量审计全部 Recipe
-   * 对活跃 Recipe 逐个评分，返回低于阈值的列表
-   */
-  async #taskQualityAudit({ threshold = 0.6, maxCount = 100 } = {}) {
-    const ctx = this.#getToolContext();
-    const knowledgeService = ctx.container.get('knowledgeService');
-
-    const { items = [], data = [] } = await knowledgeService.list(
-      { lifecycle: 'active' },
-      { page: 1, pageSize: maxCount }
-    );
-    const recipes = items.length > 0 ? items : data;
-    if (recipes.length === 0) {
-      return { total: 0, lowQuality: [], message: 'No active recipes' };
-    }
-
-    const lowQuality = [];
-    const gradeDistribution = { A: 0, B: 0, C: 0, D: 0, F: 0 };
-
-    for (const recipe of recipes) {
-      const scoreResult = await this.executeTool('quality_score', { recipe });
-      if (scoreResult.grade) {
-        gradeDistribution[scoreResult.grade] = (gradeDistribution[scoreResult.grade] || 0) + 1;
-      }
-      if (scoreResult.score < threshold) {
-        lowQuality.push({
-          id: recipe.id,
-          title: recipe.title,
-          score: scoreResult.score,
-          grade: scoreResult.grade,
-          dimensions: scoreResult.dimensions,
-        });
-      }
-    }
-
-    lowQuality.sort((a, b) => a.score - b.score);
-
-    return {
-      total: recipes.length,
-      threshold,
-      gradeDistribution,
-      lowQualityCount: lowQuality.length,
-      lowQuality,
-    };
-  }
-
-  /**
-   * 任务: Guard 完整扫描
-   * 对代码运行全部 Guard 规则 + 生成修复建议
-   */
-  async #taskGuardFullScan({ code, language, filePath } = {}) {
-    if (!code) {
-      return { error: 'code is required' };
-    }
-
-    // Step 1: 静态检查
-    const checkResult = await this.executeTool('guard_check_code', {
-      code,
-      language: language || 'unknown',
-      scope: 'project',
-    });
-
-    // Step 2: 如果有违规且 AI 可用，生成修复建议
-    let suggestions = null;
-    if (checkResult.violationCount > 0 && this.#aiProvider) {
-      try {
-        const violationSummary = (checkResult.violations || [])
-          .slice(0, 5)
-          .map(
-            (v) =>
-              `- [${v.severity}] ${v.message || v.ruleName} (line ${v.line || v.matches?.[0]?.line || '?'})`
-          )
-          .join('\n');
-
-        const prompt = `以下代码存在 Guard 规则违规。请为每个违规提供修复建议。
-
-违规列表:
-${violationSummary}
-
-代码片段:
-\`\`\`${language || ''}
-${code.substring(0, 3000)}
-\`\`\`
-
-请用 JSON 数组格式返回建议: [{"violation": "...", "suggestion": "...", "fixExample": "..."}]`;
-
-        suggestions =
-          (await this.#aiProvider.chatWithStructuredOutput(prompt, {
-            openChar: '[',
-            closeChar: ']',
-            temperature: 0.3,
-          })) || [];
-      } catch {
-        /* AI suggestions optional */
-      }
-    }
-
-    return {
-      filePath: filePath || '(inline)',
-      language,
-      violationCount: checkResult.violationCount,
-      violations: checkResult.violations,
-      suggestions,
-    };
-  }
-
   // ─── 内置 DAG 管线注册 ─────────────────────────────────
 
   /**
@@ -1905,88 +1648,6 @@ ${code.substring(0, 3000)}
 
   // ─── Native Tool Calling 内部方法 ──────────────────────
 
-  /**
-   * 构建原生函数调用模式的系统提示词
-   *
-   * 设计原则:
-   *   - 精简: bootstrap 模式不注入 SOUL.md 人格（节省 ~500 token）
-   *   - 分层: 静态指令放 systemPrompt，动态上下文放 user prompt
-   *   - 控制通过 PhaseRouter 状态机实现，不通过追加 user 消息
-   *   - 工具描述已通过 functionDeclarations 传递，不重复
-   */
-  #buildNativeToolSystemPrompt(budget = DEFAULT_BUDGET) {
-    // 用户对话模式: 完整提示词（含 SOUL、Memory、项目概况）
-    if (this.#currentSource !== 'system') {
-      let soulSection = '';
-      try {
-        if (fs.existsSync(SOUL_PATH)) {
-          soulSection = `\n${fs.readFileSync(SOUL_PATH, 'utf-8').trim()}\n`;
-        }
-      } catch {
-        /* SOUL.md not available */
-      }
-
-      return `${soulSection}
-你是 AutoSnippet 项目的统一 AI 中心。项目内所有 AI 推理和分析都通过你执行。
-${this.#projectBriefingCache}${this.#memory?.toPromptSection({ source: 'user' }) || ''}${this.#semanticMemory?.toPromptSection({ source: 'user' }) || ''}
-
-## 使用规则
-1. 当需要查询数据时，直接调用相应工具。
-2. 工具参数严格按照工具声明中的 schema 传递。
-3. 对于代码分析任务，先 search_project_code 搜索，再 read_project_file 读取。
-4. 当工具返回错误时，尝试不同参数或方法。`;
-    }
-
-    // Bootstrap 系统模式: LLM 以领域大脑的能力处理任务
-    return `你以「领域大脑」的能力来处理任务 — 你对软件工程领域拥有深厚的专家知识。
-你将分析一个真实项目，自主发现其中有价值的代码知识。
-${this.#projectBriefingCache}
-
-## 你的能力定位
-你具备深度技术洞察力，能够理解代码背后的设计意图。
-你知道什么知识对开发团队最有价值 — 不是显而易见的样板代码，
-而是体现项目独有设计决策、架构模式和工程智慧的知识。
-
-## 你的工作方式
-1. **全局感知** → list_project_structure 了解项目结构
-2. **定向探索** → get_file_summary 快速了解文件角色
-3. **深入研读** → search_project_code / read_project_file 获取真实代码
-4. **语义发现** → semantic_search_code 在知识库查找相关知识
-5. **知识产出** → submit_knowledge 提交有价值的发现
-
-## 高效使用工具（节省轮次）
-- **批量搜索**: search_project_code({ patterns: ["keywordA", "keywordB", "keywordC"] })
-- **批量读文件**: read_project_file({ filePaths: ["path/a.m", "path/b.m"] })
-- 合并同类请求为一次调用，避免逐个搜索/读取浪费轮次。
-
-## 「项目特写」= 基本用法 + 项目特征融合
-submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基本用法与本项目的特征融合为一体:
-1. **项目选择了什么**: 采用了哪种写法/模式/约定
-2. **为什么这样选**: 统计数据（N 个文件、占比 M%）
-3. **项目禁止什么**: 被放弃的写法、反模式、显式禁用标记
-4. **新代码怎么写**: 可直接复制使用的代码模板
-
-## 核心原则
-- 代码必须真实，来自工具返回，不可编造
-- 引用具体类名、方法名、数字，禁止「本模块」「该文件」等泛化描述
-- 质量优先于数量，证据不足宁可不提交
-- 高效利用步数 (≤${budget.maxIterations} 轮)`;
-  }
-
-  /**
-   * 清理最终回答（去除 Thought/preamble + MEMORY 标签）
-   */
-  #cleanFinalAnswer(response) {
-    if (!response) {
-      return '';
-    }
-    return response
-      .replace(/^(Final Answer|最终回答|Answer)\s*[:：]\s*/i, '')
-      .replace(/\[MEMORY:\w+\]\s*[\s\S]*?\s*\[\/MEMORY\]/g, '')
-      .replace(/\n{3,}/g, '\n\n')
-      .trim();
-  }
-
   /**
    * 获取工具执行上下文
    * @param {object} [extras] — 额外注入到上下文的字段（如 _sessionToolCalls）
@@ -2059,46 +1720,6 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
     }
   }
 
-  /**
-   * 构建项目概况注入到系统提示词（每次 execute 刷新一次）
-   * 单次 SQL 聚合 < 5ms，静默降级
-   */
-  async #buildProjectBriefing() {
-    try {
-      const db = this.#container?.get('database');
-      if (!db) {
-        return '';
-      }
-      // knowledgeType → kind 映射:
-      //   rule: code-standard, code-style, best-practice, boundary-constraint
-      //   pattern: code-pattern, architecture, solution
-      //   fact: code-relation, inheritance, call-chain, data-flow, module-dependency
-      // V3: knowledge_entries 统一表（candidates 已合并，lifecycle 替代 status）
-      const stats = db
-        .prepare(`
-        SELECT
-          (SELECT COUNT(*) FROM knowledge_entries WHERE lifecycle = 'active') as recipeCount,
-          (SELECT COUNT(*) FROM knowledge_entries WHERE lifecycle = 'active' AND knowledgeType IN ('code-standard','code-style','best-practice','boundary-constraint')) as ruleCount,
-          (SELECT COUNT(*) FROM knowledge_entries WHERE lifecycle = 'active' AND knowledgeType IN ('code-pattern','architecture','solution')) as patternCount,
-          (SELECT COUNT(*) FROM knowledge_entries WHERE lifecycle = 'active' AND knowledgeType IN ('code-relation','inheritance','call-chain','data-flow','module-dependency')) as factCount,
-          (SELECT COUNT(*) FROM knowledge_entries WHERE lifecycle = 'active' AND knowledgeType = 'boundary-constraint') as guardRuleCount,
-          (SELECT COUNT(*) FROM knowledge_entries WHERE lifecycle = 'pending') as pendingCandidates,
-          (SELECT COUNT(*) FROM knowledge_entries) as totalCandidates
-      `)
-        .get();
-      if (!stats || stats.recipeCount === 0) {
-        return '\n## 项目状态\n⚠️ 知识库为空。建议先执行冷启动（bootstrap_knowledge）。\n';
-      }
-      let section = `\n## 项目状态\n- 知识库: ${stats.recipeCount} 条 Recipe（${stats.ruleCount || 0} rule / ${stats.patternCount || 0} pattern / ${stats.factCount || 0} fact）\n- Guard 规则: ${stats.guardRuleCount || 0} 条\n- 候选: ${stats.pendingCandidates} 条待审 / ${stats.totalCandidates} 条总计\n`;
-      if (stats.pendingCandidates > 10) {
-        section += `\n⚠️ 有 ${stats.pendingCandidates} 条候选积压，建议执行批量审核。\n`;
-      }
-      return section;
-    } catch {
-      return ''; // DB 不可用时静默降级
-    }
-  }
-
   /**
    * 异步初始化 ProjectSemanticMemory (Tier 3)
    * 在构造函数中调用 (fire-and-forget)