autosnippet 3.0.11 → 3.0.13

package/lib/service/chat/ChatAgentPrompts.js

@@ -0,0 +1,149 @@
+/**
+ * ChatAgentPrompts — ChatAgent 提示词构建和文本处理方法（从 ChatAgent.js 提取）
+ */
+
+import fs from 'node:fs';
+
+/**
+ * 构建原生函数调用模式的系统提示词
+ *
+ * 设计原则:
+ *   - 精简: bootstrap 模式不注入 SOUL.md 人格（节省 ~500 token）
+ *   - 分层: 静态指令放 systemPrompt，动态上下文放 user prompt
+ *   - 控制通过 PhaseRouter 状态机实现，不通过追加 user 消息
+ *   - 工具描述已通过 functionDeclarations 传递，不重复
+ *
+ * @param {object} options
+ * @param {string} options.currentSource — 'user' | 'system'
+ * @param {string} options.projectBriefingCache — 项目概况缓存文本
+ * @param {import('./Memory.js').Memory|null} options.memory — 跨对话记忆
+ * @param {import('./ProjectSemanticMemory.js').ProjectSemanticMemory|null} options.semanticMemory — Tier 3 语义记忆
+ * @param {object} options.budget — 预算配置
+ * @param {string} options.soulPath — SOUL.md 文件路径
+ * @returns {string}
+ */
+export function buildNativeToolSystemPrompt({
+  currentSource,
+  projectBriefingCache,
+  memory,
+  semanticMemory,
+  budget = {},
+  soulPath,
+}) {
+  // 用户对话模式: 完整提示词（含 SOUL、Memory、项目概况）
+  if (currentSource !== 'system') {
+    let soulSection = '';
+    try {
+      if (soulPath && fs.existsSync(soulPath)) {
+        soulSection = `\n${fs.readFileSync(soulPath, 'utf-8').trim()}\n`;
+      }
+    } catch {
+      /* SOUL.md not available */
+    }
+
+    return `${soulSection}
+你是 AutoSnippet 项目的统一 AI 中心。项目内所有 AI 推理和分析都通过你执行。
+${projectBriefingCache}${memory?.toPromptSection({ source: 'user' }) || ''}${semanticMemory?.toPromptSection({ source: 'user' }) || ''}
+
+## 使用规则
+1. 当需要查询数据时，直接调用相应工具。
+2. 工具参数严格按照工具声明中的 schema 传递。
+3. 对于代码分析任务，先 search_project_code 搜索，再 read_project_file 读取。
+4. 当工具返回错误时，尝试不同参数或方法。`;
+  }
+
+  // Bootstrap 系统模式: LLM 以领域大脑的能力处理任务
+  return `你以「领域大脑」的能力来处理任务 — 你对软件工程领域拥有深厚的专家知识。
+你将分析一个真实项目，自主发现其中有价值的代码知识。
+${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} 轮)`;
+}
+
+/**
+ * 构建项目概况注入到系统提示词（每次 execute 刷新一次）
+ * 单次 SQL 聚合 < 5ms，静默降级
+ *
+ * @param {object} options
+ * @param {import('../../injection/ServiceContainer.js').ServiceContainer} options.container
+ * @returns {Promise<string>}
+ */
+export async function buildProjectBriefing({ container }) {
+  try {
+    const db = 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 不可用时静默降级
+  }
+}
+
+/**
+ * 清理最终回答（去除 Thought/preamble + MEMORY 标签）
+ * @param {string} response
+ * @returns {string}
+ */
+export function 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();
+}

package/lib/service/chat/ChatAgentTasks.js

@@ -0,0 +1,297 @@
+/**
+ * ChatAgentTasks — ChatAgent 预定义任务方法（从 ChatAgent.js 提取）
+ *
+ * 每个任务接收 context 对象: { executeTool, aiProvider, container, logger }
+ * - executeTool(toolName, params) — 执行指定工具
+ * - aiProvider — AI Provider 实例
+ * - container — ServiceContainer
+ * - logger — Logger 实例
+ */
+
+/**
+ * 任务: 提交前查重 + 质量预评
+ * 1. check_duplicate → 若发现相似 ≥ 0.7 则建议合并
+ * 2. 顺便返回质量评估建议
+ */
+export async function taskCheckAndSubmit(context, { candidate, projectRoot }) {
+  const { executeTool, aiProvider } = context;
+
+  // Step 1: 查重
+  const duplicates = await 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 && 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 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，两两分析可能的关系
+ */
+export async function taskDiscoverAllRelations(context, { batchSize = 20 } = {}) {
+  const { executeTool, aiProvider, container, logger } = context;
+
+  const knowledgeService = container.get('knowledgeService');
+  if (!knowledgeService) {
+    throw new Error('KnowledgeService 不可用');
+  }
+
+  if (!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 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++;
+        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++;
+      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 补全候选语义字段
+ */
+export async function taskFullEnrich(context, { status = 'pending', maxCount = 50 } = {}) {
+  const { executeTool, container } = context;
+
+  const knowledgeService = 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 executeTool('enrich_candidate', {
+    candidateIds: needEnrich.map((c) => c.id).slice(0, 20),
+  });
+
+  return result;
+}
+
+/**
+ * 任务: 批量质量审计全部 Recipe
+ * 对活跃 Recipe 逐个评分，返回低于阈值的列表
+ */
+export async function taskQualityAudit(context, { threshold = 0.6, maxCount = 100 } = {}) {
+  const { executeTool, container } = context;
+
+  const knowledgeService = 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 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 规则 + 生成修复建议
+ */
+export async function taskGuardFullScan(context, { code, language, filePath } = {}) {
+  const { executeTool, aiProvider } = context;
+
+  if (!code) {
+    return { error: 'code is required' };
+  }
+
+  // Step 1: 静态检查
+  const checkResult = await executeTool('guard_check_code', {
+    code,
+    language: language || 'unknown',
+    scope: 'project',
+  });
+
+  // Step 2: 如果有违规且 AI 可用，生成修复建议
+  let suggestions = null;
+  if (checkResult.violationCount > 0 && 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 aiProvider.chatWithStructuredOutput(prompt, {
+          openChar: '[',
+          closeChar: ']',
+          temperature: 0.3,
+        })) || [];
+    } catch {
+      /* AI suggestions optional */
+    }
+  }
+
+  return {
+    filePath: filePath || '(inline)',
+    language,
+    violationCount: checkResult.violationCount,
+    violations: checkResult.violations,
+    suggestions,
+  };
+}

package/lib/service/chat/tools/_shared.js

@@ -0,0 +1,61 @@
+/**
+ * _shared.js — 多个工具模块共享的常量和辅助函数
+ */
+
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export const PROJECT_ROOT = path.resolve(__dirname, '../../../..');
+/** skills/ 目录绝对路径 */
+export const SKILLS_DIR = path.resolve(PROJECT_ROOT, 'skills');
+/** 项目级 skills 目录 */
+export const PROJECT_SKILLS_DIR = path.resolve(PROJECT_ROOT, '.autosnippet', 'skills');
+
+// Bootstrap 维度展示分组 — 将 9 个细粒度维度合并为 4 个展示组
+export const DIMENSION_DISPLAY_GROUP = {
+  architecture: 'architecture', // → 架构与设计
+  'code-pattern': 'architecture', // → 架构与设计
+  'project-profile': 'architecture', // → 架构与设计
+  'best-practice': 'best-practice', // → 规范与实践
+  'code-standard': 'best-practice', // → 规范与实践
+  'event-and-data-flow': 'event-and-data-flow', // → 事件与数据流
+  'objc-deep-scan': 'objc-deep-scan', // → 深度扫描
+  'category-scan': 'objc-deep-scan', // → 深度扫描
+  'agent-guidelines': 'agent-guidelines', // skill-only
+};
+
+/**
+ * 基于维度元数据 (dimensionMeta) 检查提交是否合法
+ * @param {{ id: string, outputType: 'candidate'|'skill'|'dual', allowedKnowledgeTypes: string[] }} dimensionMeta
+ * @param {object} params - submit_knowledge 的参数
+ * @param {object} [logger]
+ * @returns {{ status: string, reason: string } | null} 不合法返回 rejected，合法返回 null
+ */
+export function checkDimensionType(dimensionMeta, params, logger) {
+  // 1. Skill-only 维度不允许提交 Candidate
+  if (dimensionMeta.outputType === 'skill') {
+    logger?.info(
+      `[submit_knowledge] ✗ rejected — dimension "${dimensionMeta.id}" is skill-only, cannot submit candidates`
+    );
+    return {
+      status: 'rejected',
+      reason: `当前维度 "${dimensionMeta.id}" 的输出类型为 skill-only，不允许调用 submit_knowledge。请只在最终回复中提供 dimensionDigest JSON。`,
+    };
+  }
+
+  // 2. knowledgeType 校验 — 不在允许列表时自动修正为第一个允许类型
+  const allowed = dimensionMeta.allowedKnowledgeTypes || [];
+  if (allowed.length > 0 && params.knowledgeType) {
+    if (!allowed.includes(params.knowledgeType)) {
+      const corrected = allowed[0];
+      logger?.warn(
+        `[submit_knowledge] knowledgeType "${params.knowledgeType}" → "${corrected}" (auto-corrected for dimension "${dimensionMeta.id}")`
+      );
+      params.knowledgeType = corrected;
+    }
+  }
+
+  return null;
+}