autosnippet 2.0.2 → 2.4.0

package/lib/service/chat/ChatAgent.js

@@ -27,9 +27,12 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { TaskPipeline } from './TaskPipeline.js';
+import { Memory } from './Memory.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SKILLS_DIR = path.resolve(__dirname, '../../../skills');
+const PROJECT_ROOT = path.resolve(__dirname, '../../..');
+const SKILLS_DIR = path.resolve(PROJECT_ROOT, 'skills');
+const SOUL_PATH = path.resolve(PROJECT_ROOT, 'SOUL.md');
 const MAX_ITERATIONS = 6;
 
 export class ChatAgent {
@@ -39,6 +42,10 @@ export class ChatAgent {
   #logger;
   /** @type {Map<string, TaskPipeline>} */
   #pipelines = new Map();
+  /** @type {string} 缓存的项目概况（每次 execute 刷新一次） */
+  #projectBriefingCache = '';
+  /** @type {Memory|null} 跨对话轻量记忆 */
+  #memory = null;
 
   /**
    * @param {object} opts
@@ -55,6 +62,12 @@ export class ChatAgent {
     /** 是否有 AI Provider（只读） */
     this.hasAI = !!aiProvider;
 
+    // 初始化跨对话记忆
+    try {
+      const projectRoot = container?.singletons?._projectRoot || process.cwd();
+      this.#memory = new Memory(projectRoot);
+    } catch { /* Memory init failed, degrade silently */ }
+
     // 注册内置 DAG 管线
     this.#registerBuiltinPipelines();
   }
@@ -71,6 +84,9 @@ export class ChatAgent {
    * @returns {Promise<{reply: string, toolCalls: Array, hasContext: boolean}>}
    */
   async execute(prompt, { history = [] } = {}) {
+    // 每次对话刷新项目概况（不是每轮 ReAct）
+    this.#projectBriefingCache = await this.#buildProjectBriefing();
+
     const toolSchemas = this.#toolRegistry.getToolSchemas();
     const systemPrompt = this.#buildSystemPrompt(toolSchemas);
 
@@ -97,11 +113,9 @@ export class ChatAgent {
 
       if (!action) {
         // 没有 Action → 最终回答
-        return {
-          reply: this.#cleanFinalAnswer(response),
-          toolCalls,
-          hasContext: toolCalls.length > 0,
-        };
+        const reply = this.#cleanFinalAnswer(response);
+        this.#extractMemory(prompt, reply);
+        return { reply, toolCalls, hasContext: toolCalls.length > 0 };
       }
 
       // 执行工具
@@ -141,8 +155,11 @@ export class ChatAgent {
       systemPrompt: '直接回答用户问题，不要再调用工具。',
     });
 
+    const finalReply = this.#cleanFinalAnswer(finalResponse);
+    this.#extractMemory(prompt, finalReply);
+
     return {
-      reply: this.#cleanFinalAnswer(finalResponse),
+      reply: finalReply,
       toolCalls,
       hasContext: toolCalls.length > 0,
     };
@@ -286,11 +303,14 @@ ${highSim.map(s => `- ${s.title} (相似度: ${s.similarity})`).join('\n')}
   async #taskDiscoverAllRelations({ batchSize = 20 } = {}) {
     const ctx = this.#getToolContext();
     const recipeService = ctx.container.get('recipeService');
+    if (!recipeService) throw new Error('RecipeService 不可用');
+
+    if (!ctx.aiProvider) throw new Error('AI Provider 未配置，请先设置 API Key');
 
     // 获取所有 recipe
     const { items = [], data = [] } = await recipeService.listRecipes({}, { page: 1, pageSize: 500 });
     const recipes = items.length > 0 ? items : data;
-    if (recipes.length < 2) return { discovered: 0, message: 'Need at least 2 recipes' };
+    if (recipes.length < 2) return { discovered: 0, totalPairs: 0, message: `只有 ${recipes.length} 条 Recipe，至少需要 2 条` };
 
     // 按 batch 分组分析
     const pairs = [];
@@ -302,24 +322,41 @@ ${highSim.map(s => `- ${s.title} (相似度: ${s.similarity})`).join('\n')}
 
     let discovered = 0;
     const results = [];
+    let batchErrors = 0;
 
-    // 分批处理
+    // 分批处理，单批失败不终止整体
     for (let b = 0; b < pairs.length; b += batchSize) {
       const batch = pairs.slice(b, b + batchSize);
-      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: (a.content || a.code || '').substring(0, 500) },
-          b: { id: b.id, title: b.title, category: b.category, language: b.language, code: (b.content || b.code || '').substring(0, 500) },
-        })),
-      });
+      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.relations) {
-        discovered += result.relations.length;
-        results.push(...result.relations);
+        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, relations: results };
+    return {
+      discovered,
+      totalPairs: pairs.length,
+      totalBatches: Math.ceil(pairs.length / batchSize),
+      batchErrors,
+      relations: results,
+    };
   }
 
   /**
@@ -554,9 +591,18 @@ ${code.substring(0, 3000)}
       ? `\n## 可用 Skills\n通过 load_skill 工具按需加载领域知识文档，获取操作指南和最佳实践参考。\n\n| Skill | 说明 |\n|---|---|\n${skillList.map(s => `| ${s.name} | ${s.summary || '-'} |`).join('\n')}\n\n**场景 → Skill 推荐**：\n- 冷启动、初始化 → autosnippet-coldstart\n- 深度项目分析 → autosnippet-analysis\n- 候选生成 → autosnippet-candidates + autosnippet-create\n- 代码规范审计 → autosnippet-guard\n- Snippet 概念解释 → autosnippet-concepts\n- 生命周期管理 → autosnippet-lifecycle\n- Swift/ObjC/JS·TS 语言参考 → autosnippet-reference-{swift,objc,jsts}\n- 项目结构分析 → autosnippet-structure\n- 不确定该用哪个 → autosnippet-intent\n`
       : '';
 
-    return `你是 AutoSnippet 项目的统一 AI 中心。项目内所有 AI 推理和分析都通过你执行。
-你拥有 ${toolSchemas.length} 个工具覆盖知识库管理全链路：搜索、提交、审核、质量评估、Guard 检查、知识图谱、冷启动等。
+    // SOUL — AI 人格注入（如果 SOUL.md 存在）
+    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 推理和分析都通过你执行。
+你拥有 ${toolSchemas.length} 个工具覆盖知识库管理全链路：搜索、提交、审核、质量评估、Guard 检查、知识图谱、冷启动等。
+${this.#projectBriefingCache}${this.#memory?.toPromptSection() || ''}
 可用工具:
 
 ${toolDescriptions}
@@ -579,7 +625,9 @@ ${skillSection}
    - 候选创建/提交 → load_skill("autosnippet-candidates")
    - 代码规范/Guard → load_skill("autosnippet-guard")
    - 不确定做什么 → load_skill("autosnippet-intent")
-8. 你可以组合多个工具完成复杂任务（如：查重 → 提交 → 质量评分 → 知识图谱关联）。`;
+8. 你可以组合多个工具完成复杂任务（如：查重 → 提交 → 质量评分 → 知识图谱关联）。
+9. 当工具返回 _meta.confidence = "none" 时，告知用户无匹配并建议下一步，不要凭空编造。当 _meta.confidence = "low" 时，明确标注结果不确定性。
+10. 优先使用组合工具（analyze_code, knowledge_overview, submit_with_check）减少调用轮次。`;
   }
 
   /**
@@ -640,24 +688,39 @@ ${skillSection}
 
   /**
    * 列出可用的 Skills 及其摘要（用于系统提示词）
+   * 加载顺序: 内置 skills/ → 项目级 .autosnippet/skills/（同名覆盖）
    * @returns {{ name: string, summary: string }[]}
    */
   #listAvailableSkills() {
+    const skillMap = new Map();
+
+    // 1. 内置 Skills
+    this.#loadSkillsFromDir(SKILLS_DIR, skillMap);
+
+    // 2. 项目级 Skills（覆盖同名内置 Skill）
+    const projectSkillsDir = path.resolve(PROJECT_ROOT, '.autosnippet', 'skills');
+    this.#loadSkillsFromDir(projectSkillsDir, skillMap);
+
+    return Array.from(skillMap.values());
+  }
+
+  /**
+   * 从目录加载 Skills 到 Map
+   */
+  #loadSkillsFromDir(dir, skillMap) {
     try {
-      const dirs = fs.readdirSync(SKILLS_DIR, { withFileTypes: true })
+      const dirs = fs.readdirSync(dir, { withFileTypes: true })
         .filter(d => d.isDirectory())
         .map(d => d.name);
-      return dirs.map(name => {
-        const skillPath = path.join(SKILLS_DIR, name, 'SKILL.md');
+      for (const name of dirs) {
+        const skillPath = path.join(dir, name, 'SKILL.md');
         let summary = '';
         try {
           const raw = fs.readFileSync(skillPath, 'utf-8');
-          // 从 frontmatter description 或首行 # 后提取摘要
           const fmMatch = raw.match(/^---[\s\S]*?description:\s*["']?(.+?)["']?\s*$/m);
           if (fmMatch) {
             summary = fmMatch[1];
           } else {
-            // fallback: 取首个非空非标题行
             const lines = raw.split('\n');
             for (const line of lines) {
               const trimmed = line.trim();
@@ -668,10 +731,88 @@ ${skillSection}
             }
           }
         } catch { /* SKILL.md not found */ }
-        return { name, summary };
-      });
+        skillMap.set(name, { name, summary });
+      }
+    } catch { /* directory not found */ }
+  }
+
+  /**
+   * 构建项目概况注入到系统提示词（每次 execute 刷新一次）
+   * 单次 SQL 聚合 < 5ms，静默降级
+   */
+  async #buildProjectBriefing() {
+    try {
+      const db = this.#container?.get('database');
+      if (!db) return '';
+      // knowledge_type → 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
+      const stats = db.prepare(`
+        SELECT
+          (SELECT COUNT(*) FROM recipes) as recipeCount,
+          (SELECT COUNT(*) FROM recipes WHERE knowledge_type IN ('code-standard','code-style','best-practice','boundary-constraint')) as ruleCount,
+          (SELECT COUNT(*) FROM recipes WHERE knowledge_type IN ('code-pattern','architecture','solution')) as patternCount,
+          (SELECT COUNT(*) FROM recipes WHERE knowledge_type IN ('code-relation','inheritance','call-chain','data-flow','module-dependency')) as factCount,
+          (SELECT COUNT(*) FROM recipes WHERE knowledge_type = 'boundary-constraint') as guardRuleCount,
+          (SELECT COUNT(*) FROM candidates WHERE status='pending') as pendingCandidates,
+          (SELECT COUNT(*) FROM candidates) 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 [];
+      return ''; // DB 不可用时静默降级
+    }
+  }
+
+  /**
+   * 从用户消息中提取偏好/决策写入 Memory
+   * 使用正则匹配，不调 AI — 零延迟
+   */
+  #extractMemory(prompt, _reply) {
+    if (!this.#memory) return;
+    try {
+      const prefPatterns = [
+        /我们(项目|团队)?(不用|不使用|禁止|避免|偏好|习惯|规范是)/,
+        /以后(都|请|要)/,
+        /记住/,
+      ];
+      if (prefPatterns.some(p => p.test(prompt))) {
+        this.#memory.append({
+          type: 'preference',
+          content: prompt.substring(0, 200),
+          ttl: 30,
+        });
+      }
+    } catch { /* memory write failure is non-critical */ }
+  }
+
+  /**
+   * 事件驱动入口（P2 预留接口）
+   * @param {{ type: string, payload: object, source?: string }} event
+   */
+  async executeEvent(event) {
+    const { type, payload } = event;
+    const prompt = this.#eventToPrompt(type, payload);
+    return this.execute(prompt, { history: [] });
+  }
+
+  #eventToPrompt(type, payload) {
+    switch (type) {
+      case 'file_saved':
+        return `文件 ${payload.filePath} 刚被保存，变更了 ${payload.changedLines} 行。请分析是否有值得提取为 Recipe 的代码模式。如果有，说明原因；没有就说"无需操作"。`;
+      case 'candidate_backlog':
+        return `当前有 ${payload.count} 条候选积压（最早 ${payload.oldest}）。请按质量分类：哪些值得审核、哪些可以直接拒绝、哪些需要补充信息。`;
+      case 'scheduled_health':
+        return `请执行知识库健康检查：Recipe 覆盖率、过时标记、Guard 规则有效性。给出简要报告。`;
+      default:
+        return `事件: ${type}\n${JSON.stringify(payload)}`;
     }
   }
 

package/lib/service/chat/Memory.js

@@ -0,0 +1,104 @@
+/**
+ * Memory — 跨对话轻量记忆
+ *
+ * 设计:
+ * - JSONL 文件存储，每行一条记忆
+ * - 支持 TTL 自动过期
+ * - 上限 maxEntries，超出时截断旧条目
+ * - 读写均做静默降级（Memory 是增强，不是核心路径）
+ *
+ * 记忆类型:
+ * - preference: 用户偏好（"我们不用 singleton"、"以后用 DI"）
+ * - decision:   关键决策（"Network 模块审核通过"）
+ * - context:    项目上下文（"主语言是 Swift，使用 SPM"）
+ *
+ * 文件路径: .autosnippet/memory.jsonl
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export class Memory {
+  #filePath;
+  #maxEntries;
+
+  /**
+   * @param {string} projectRoot — 用户项目根目录
+   * @param {object} [opts]
+   * @param {number} [opts.maxEntries=50] — 最大记忆条数
+   */
+  constructor(projectRoot, { maxEntries = 50 } = {}) {
+    this.#filePath = path.join(projectRoot, '.autosnippet', 'memory.jsonl');
+    this.#maxEntries = maxEntries;
+  }
+
+  /**
+   * 读取最近 N 条记忆，过滤过期项
+   * @param {number} [limit=20]
+   * @returns {{ ts: string, type: string, content: string, ttl?: number }[]}
+   */
+  load(limit = 20) {
+    try {
+      if (!fs.existsSync(this.#filePath)) return [];
+      const raw = fs.readFileSync(this.#filePath, 'utf-8').trim();
+      if (!raw) return [];
+      const lines = raw.split('\n').filter(Boolean);
+      const now = Date.now();
+      return lines
+        .map(l => { try { return JSON.parse(l); } catch { return null; } })
+        .filter(Boolean)
+        .filter(m => !m.ttl || (now - new Date(m.ts).getTime()) < m.ttl * 86400000)
+        .slice(-limit);
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * 追加一条记忆
+   * @param {{ type: string, content: string, ttl?: number }} entry
+   */
+  append(entry) {
+    try {
+      const dir = path.dirname(this.#filePath);
+      fs.mkdirSync(dir, { recursive: true });
+      const line = JSON.stringify({ ts: new Date().toISOString(), ...entry });
+      fs.appendFileSync(this.#filePath, line + '\n', 'utf-8');
+      this.#compact();
+    } catch { /* write failure non-critical */ }
+  }
+
+  /**
+   * 生成供系统提示词的记忆摘要
+   * @returns {string}
+   */
+  toPromptSection() {
+    const memories = this.load();
+    if (memories.length === 0) return '';
+    const lines = memories.map(m => `- [${m.type}] ${m.content}`).join('\n');
+    return `\n## 历史记忆\n以下是之前对话中积累的项目偏好和决策，请参考：\n${lines}\n`;
+  }
+
+  /**
+   * 当前记忆条数
+   */
+  get size() {
+    return this.load(this.#maxEntries).length;
+  }
+
+  /**
+   * 超过 maxEntries 时截断旧条目
+   */
+  #compact() {
+    try {
+      const raw = fs.readFileSync(this.#filePath, 'utf-8').trim();
+      if (!raw) return;
+      const lines = raw.split('\n').filter(Boolean);
+      if (lines.length > this.#maxEntries) {
+        fs.writeFileSync(this.#filePath, lines.slice(-this.#maxEntries).join('\n') + '\n', 'utf-8');
+      }
+    } catch { /* ignore */ }
+  }
+}
+
+export default Memory;