autosnippet 2.4.0 → 2.6.0

package/lib/injection/ServiceContainer.js

@@ -52,7 +52,7 @@ import { ALL_TOOLS } from '../service/chat/tools.js';
 import { SkillHooks } from '../service/skills/SkillHooks.js';
 
 // ─── P3: Infrastructure ──────────────────────────────
-// EventBus / PluginManager imports removed — source files retained for future use
+import { EventBus } from '../infrastructure/event/EventBus.js';
 
 /**
  * DependencyInjection 容器
@@ -201,7 +201,13 @@ export class ServiceContainer {
       return this.singletons.gateway;
     });
 
-
+    // EventBus（全局事件总线）
+    this.register('eventBus', () => {
+      if (!this.singletons.eventBus) {
+        this.singletons.eventBus = new EventBus({ maxListeners: 30 });
+      }
+      return this.singletons.eventBus;
+    });
   }
 
   /**

package/lib/service/chat/ChatAgent.js

@@ -28,6 +28,7 @@ import { fileURLToPath } from 'node:url';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { TaskPipeline } from './TaskPipeline.js';
 import { Memory } from './Memory.js';
+import { ConversationStore } from './ConversationStore.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = path.resolve(__dirname, '../../..');
@@ -46,6 +47,10 @@ export class ChatAgent {
   #projectBriefingCache = '';
   /** @type {Memory|null} 跨对话轻量记忆 */
   #memory = null;
+  /** @type {ConversationStore|null} 对话持久化 */
+  #conversations = null;
+  /** @type {string|null} 当前 execute 调用的 source — 'user' | 'system' */
+  #currentSource = null;
 
   /**
    * @param {object} opts
@@ -62,11 +67,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 */ }
+      this.#conversations = new ConversationStore(projectRoot);
+    } catch { /* Memory/ConversationStore init failed, degrade silently */ }
 
     // 注册内置 DAG 管线
     this.#registerBuiltinPipelines();
@@ -81,9 +87,20 @@ export class ChatAgent {
    * @param {string} prompt — 用户消息
    * @param {object} opts
    * @param {Array}  opts.history — 对话历史 [{role, content}]
-   * @returns {Promise<{reply: string, toolCalls: Array, hasContext: boolean}>}
+   * @param {string} [opts.conversationId] — 对话 ID（启用持久化时）
+   * @param {'user'|'system'} [opts.source='user'] — 调用来源（影响 Memory 隔离）
+   * @returns {Promise<{reply: string, toolCalls: Array, hasContext: boolean, conversationId?: string}>}
    */
-  async execute(prompt, { history = [] } = {}) {
+  async execute(prompt, { history = [], conversationId, source = 'user' } = {}) {
+    this.#currentSource = source;
+
+    // 对话持久化: 如果传了 conversationId，从 ConversationStore 加载历史
+    let effectiveHistory = history;
+    if (conversationId && this.#conversations) {
+      effectiveHistory = this.#conversations.load(conversationId);
+      this.#conversations.append(conversationId, { role: 'user', content: prompt });
+    }
+
     // 每次对话刷新项目概况（不是每轮 ReAct）
     this.#projectBriefingCache = await this.#buildProjectBriefing();
 
@@ -92,7 +109,7 @@ export class ChatAgent {
 
     // 首次 LLM 调用
     const messages = [
-      ...history,
+      ...effectiveHistory,
       { role: 'user', content: prompt },
     ];
 
@@ -100,13 +117,34 @@ export class ChatAgent {
     let iterations = 0;
     let currentPrompt = prompt;
 
+    let consecutiveAiErrors = 0;
+
     while (iterations < MAX_ITERATIONS) {
       iterations++;
 
-      const response = await this.#aiProvider.chat(currentPrompt, {
-        history: messages.slice(0, -1), // 不含最新 user prompt
-        systemPrompt,
-      });
+      let response;
+      try {
+        response = await this.#aiProvider.chat(currentPrompt, {
+          history: messages.slice(0, -1), // 不含最新 user prompt
+          systemPrompt,
+        });
+        consecutiveAiErrors = 0;
+      } catch (aiErr) {
+        consecutiveAiErrors++;
+        this.#logger.warn(`[ChatAgent] AI call failed (attempt ${consecutiveAiErrors}): ${aiErr.message}`);
+
+        // 连续 2 次失败则降级返回错误提示
+        if (consecutiveAiErrors >= 2) {
+          const errorReply = `抱歉，AI 服务暂时不可用（${aiErr.message}）。请稍后重试，或检查 API 配置。`;
+          if (conversationId && this.#conversations) {
+            this.#conversations.append(conversationId, { role: 'assistant', content: errorReply });
+          }
+          return { reply: errorReply, toolCalls, hasContext: toolCalls.length > 0, conversationId };
+        }
+        // 首次失败：等待后重试本轮
+        await new Promise(r => setTimeout(r, 2000));
+        continue;
+      }
 
       // 尝试解析 Action 块
       const action = this.#parseAction(response);
@@ -115,7 +153,15 @@ export class ChatAgent {
         // 没有 Action → 最终回答
         const reply = this.#cleanFinalAnswer(response);
         this.#extractMemory(prompt, reply);
-        return { reply, toolCalls, hasContext: toolCalls.length > 0 };
+
+        // 持久化 assistant 回复
+        if (conversationId && this.#conversations) {
+          this.#conversations.append(conversationId, { role: 'assistant', content: reply });
+          // 消息过多时自动压缩
+          this.#autoSummarize(conversationId).catch(() => {});
+        }
+
+        return { reply, toolCalls, hasContext: toolCalls.length > 0, conversationId };
       }
 
       // 执行工具
@@ -124,11 +170,18 @@ export class ChatAgent {
         iteration: iterations,
       });
 
-      const toolResult = await this.#toolRegistry.execute(
-        action.tool,
-        action.params,
-        this.#getToolContext(),
-      );
+      let toolResult;
+      try {
+        toolResult = await this.#toolRegistry.execute(
+          action.tool,
+          action.params,
+          this.#getToolContext(),
+        );
+      } catch (toolErr) {
+        this.#logger.warn(`[ChatAgent] Tool "${action.tool}" failed: ${toolErr.message}`);
+        // 将错误反馈给 LLM，让它尝试其他方法
+        toolResult = `Error: tool "${action.tool}" failed — ${toolErr.message}. Try a different approach or provide your answer based on available information.`;
+      }
 
       toolCalls.push({
         tool: action.tool,
@@ -146,22 +199,42 @@ export class ChatAgent {
       // 追加到消息历史中以保持上下文
       messages.push({ role: 'assistant', content: response });
       messages.push({ role: 'user', content: currentPrompt });
+
+      // ── Context Window 自动压缩（Cline AutoCondense 模式）──
+      // 每轮 ReAct 后检测消息总 token，超过预算时压缩中段消息
+      this.#condenseIfNeeded(messages);
     }
 
     // 达到最大迭代次数，要求 LLM 总结
     const summaryPrompt = `You have used ${iterations} tool calls. Summarize what you found and answer the user's original question: "${prompt}"`;
-    const finalResponse = await this.#aiProvider.chat(summaryPrompt, {
-      history: messages,
-      systemPrompt: '直接回答用户问题，不要再调用工具。',
-    });
+    let finalResponse;
+    try {
+      finalResponse = await this.#aiProvider.chat(summaryPrompt, {
+        history: messages,
+        systemPrompt: '直接回答用户问题，不要再调用工具。',
+      });
+    } catch (err) {
+      this.#logger.warn(`[ChatAgent] Final summary AI call failed: ${err.message}`);
+      // 降级：用工具调用结果拼一个简单回复
+      finalResponse = `根据 ${toolCalls.length} 次工具调用的结果，以下是收集到的信息：\n\n` +
+        toolCalls.map(tc => `• ${tc.tool}: ${typeof tc.result === 'string' ? tc.result.substring(0, 200) : JSON.stringify(tc.result).substring(0, 200)}`).join('\n') +
+        '\n\n（注：AI 总结服务暂时不可用，上述为原始工具输出摘要）';
+    }
 
     const finalReply = this.#cleanFinalAnswer(finalResponse);
     this.#extractMemory(prompt, finalReply);
 
+    // 持久化 assistant 回复
+    if (conversationId && this.#conversations) {
+      this.#conversations.append(conversationId, { role: 'assistant', content: finalReply });
+      this.#autoSummarize(conversationId).catch(() => {});
+    }
+
     return {
       reply: finalReply,
       toolCalls,
       hasContext: toolCalls.length > 0,
+      conversationId,
     };
   }
 
@@ -177,6 +250,40 @@ export class ChatAgent {
     return this.#toolRegistry.execute(toolName, params, this.#getToolContext());
   }
 
+  // ─── 对话管理 API ──────────────────────────────────────
+
+  /**
+   * 创建新对话（用于 Dashboard 前端）
+   * @param {object} [opts]
+   * @param {'user'|'system'} [opts.category='user']
+   * @param {string} [opts.title]
+   * @returns {string} conversationId
+   */
+  createConversation({ category = 'user', title = '' } = {}) {
+    if (!this.#conversations) return null;
+    return this.#conversations.create({ category, title });
+  }
+
+  /**
+   * 获取对话列表
+   * @param {object} [opts]
+   * @param {'user'|'system'} [opts.category]
+   * @param {number} [opts.limit=20]
+   * @returns {Array}
+   */
+  getConversations({ category, limit = 20 } = {}) {
+    if (!this.#conversations) return [];
+    return this.#conversations.list({ category, limit });
+  }
+
+  /**
+   * 获取 ConversationStore 实例（供外部使用，如 HTTP 路由）
+   * @returns {ConversationStore|null}
+   */
+  getConversationStore() {
+    return this.#conversations;
+  }
+
   /**
    * 预定义任务流
    * 将常见多步骤操作封装为一个任务名。
@@ -576,14 +683,38 @@ ${code.substring(0, 3000)}
 
   /**
    * 构建系统提示词（含工具描述 + Skills 感知）
+   *
+   * 工具注入策略（Lazy Tool Schema — 类似 Cline .clinerules 按需加载）:
+   *   - 首屏只注入工具名 + 一行描述（compact list）
+   *   - 系统提示词中告知 LLM 可通过 get_tool_details 获取完整参数
+   *   - 少量核心工具（search_knowledge, submit_with_check, analyze_code,
+   *     bootstrap_knowledge, load_skill, suggest_skills）直接展开完整 schema
+   *
+   * 效果: 39 个工具的 prompt 从 ~5000 tokens 降到 ~1500 tokens
    */
   #buildSystemPrompt(toolSchemas) {
-    const toolDescriptions = toolSchemas.map(t => {
-      const paramsDesc = Object.entries(t.parameters.properties || {})
-        .map(([k, v]) => `    - ${k} (${v.type}): ${v.description || ''}`)
-        .join('\n');
-      return `- **${t.name}**: ${t.description}\n  Parameters:\n${paramsDesc || '    (none)'}`;
-    }).join('\n\n');
+    // 核心工具 — 使用最频繁，直接展示完整 schema
+    const coreTools = new Set([
+      'search_knowledge', 'submit_with_check', 'analyze_code',
+      'bootstrap_knowledge', 'load_skill', 'suggest_skills',
+      'create_skill', 'knowledge_overview', 'get_tool_details',
+    ]);
+
+    const compactDescriptions = [];
+    const detailedDescriptions = [];
+
+    for (const t of toolSchemas) {
+      if (coreTools.has(t.name)) {
+        const paramsDesc = Object.entries(t.parameters.properties || {})
+          .map(([k, v]) => `    - ${k} (${v.type}): ${v.description || ''}`)
+          .join('\n');
+        detailedDescriptions.push(`- **${t.name}**: ${t.description}\n  Parameters:\n${paramsDesc || '    (none)'}`);
+      } else {
+        compactDescriptions.push(`- ${t.name}: ${t.description}`);
+      }
+    }
+
+    const toolDescriptions = `### 核心工具（完整参数）\n\n${detailedDescriptions.join('\n\n')}\n\n### 其他工具（调用 get_tool_details 获取参数详情）\n\n${compactDescriptions.join('\n')}`;
 
     // Skills 清单 — 让 LLM 知道有哪些领域知识可加载
     const skillList = this.#listAvailableSkills();
@@ -602,7 +733,7 @@ ${code.substring(0, 3000)}
     return `${soulSection}
 你是 AutoSnippet 项目的统一 AI 中心。项目内所有 AI 推理和分析都通过你执行。
 你拥有 ${toolSchemas.length} 个工具覆盖知识库管理全链路：搜索、提交、审核、质量评估、Guard 检查、知识图谱、冷启动等。
-${this.#projectBriefingCache}${this.#memory?.toPromptSection() || ''}
+${this.#projectBriefingCache}${this.#memory?.toPromptSection({ source: this.#currentSource === 'system' ? undefined : 'user' }) || ''}
 可用工具:
 
 ${toolDescriptions}
@@ -627,7 +758,9 @@ ${skillSection}
    - 不确定做什么 → load_skill("autosnippet-intent")
 8. 你可以组合多个工具完成复杂任务（如：查重 → 提交 → 质量评分 → 知识图谱关联）。
 9. 当工具返回 _meta.confidence = "none" 时，告知用户无匹配并建议下一步，不要凭空编造。当 _meta.confidence = "low" 时，明确标注结果不确定性。
-10. 优先使用组合工具（analyze_code, knowledge_overview, submit_with_check）减少调用轮次。`;
+10. 优先使用组合工具（analyze_code, knowledge_overview, submit_with_check）减少调用轮次。
+11. 当你发现用户在重复解释编码规范、操作约定或项目特有模式时，主动调用 suggest_skills 检查是否需要创建 Skill。如果有高优先级建议，向用户说明并在确认后调用 create_skill 创建。
+12. 当对话中出现值得长期记忆的信息（用户偏好、项目规范、关键决策、技术栈事实），在回复中嵌入记忆标签：\`[MEMORY:type] 内容 [/MEMORY]\`，type 可选 preference/decision/context。这些标签会被自动提取并持久化，不会显示给用户。`;
   }
 
   /**
@@ -664,13 +797,14 @@ ${skillSection}
   }
 
   /**
-   * 清理最终回答（去除 Thought/preamble）
+   * 清理最终回答（去除 Thought/preamble + MEMORY 标签）
    */
   #cleanFinalAnswer(response) {
     if (!response) return '';
-    // 去除 "Final Answer:" 前缀
     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();
   }
 
@@ -683,6 +817,7 @@ ${skillSection}
       aiProvider: this.#aiProvider,
       projectRoot: this.#container?.singletons?._projectRoot || process.cwd(),
       logger: this.#logger,
+      source: this.#currentSource,
     };
   }
 
@@ -772,27 +907,92 @@ ${skillSection}
   }
 
   /**
-   * 从用户消息中提取偏好/决策写入 Memory
-   * 使用正则匹配，不调 AI — 零延迟
+   * 从对话中提取值得记忆的信息写入 Memory
+   *
+   * 双层策略:
+   *   1. 规则快速匹配（零延迟，覆盖明确的中英文模式）
+   *   2. AI 驱动提取（异步后台，从 reply 中提取 [MEMORY] 标签）
+   *
+   * source 隔离: 标记 memory 来源，避免系统分析污染用户记忆
    */
-  #extractMemory(prompt, _reply) {
+  #extractMemory(prompt, reply) {
     if (!this.#memory) return;
+    const source = this.#currentSource || 'user';
+
     try {
+      // ── 层 1: 规则快速匹配（中文 + 英文） ──
       const prefPatterns = [
         /我们(项目|团队)?(不用|不使用|禁止|避免|偏好|习惯|规范是)/,
         /以后(都|请|要)/,
         /记住/,
+        /we\s+(don'?t|never|always|prefer|avoid)\s+use/i,
+        /remember\s+(to|that)/i,
+        /our\s+(convention|standard|rule)\s+is/i,
       ];
       if (prefPatterns.some(p => p.test(prompt))) {
         this.#memory.append({
           type: 'preference',
           content: prompt.substring(0, 200),
+          source,
           ttl: 30,
         });
       }
+
+      const decisionPatterns = [
+        /决定(了|用|采用|使用)/,
+        /(确认|同意|通过)(了|这个方案|审核)/,
+        /就(这样|这么)(做|定|办)/,
+        /let'?s\s+(go\s+with|use|adopt)/i,
+        /approved|confirmed|decided/i,
+      ];
+      if (decisionPatterns.some(p => p.test(prompt))) {
+        this.#memory.append({
+          type: 'decision',
+          content: prompt.substring(0, 200),
+          source,
+          ttl: 60,
+        });
+      }
+
+      // ── 层 2: 从 AI reply 中提取 [MEMORY] 标签 ──
+      // AI 可在回复中嵌入: [MEMORY:preference] 内容 [/MEMORY]
+      if (reply) {
+        const memoryTagRegex = /\[MEMORY:(\w+)\]\s*([\s\S]*?)\s*\[\/MEMORY\]/g;
+        let match;
+        while ((match = memoryTagRegex.exec(reply)) !== null) {
+          const type = match[1]; // preference | decision | context
+          const content = match[2].trim();
+          if (content && ['preference', 'decision', 'context'].includes(type)) {
+            this.#memory.append({
+              type,
+              content: content.substring(0, 200),
+              source,
+              ttl: type === 'context' ? 90 : type === 'decision' ? 60 : 30,
+            });
+          }
+        }
+      }
     } catch { /* memory write failure is non-critical */ }
   }
 
+  /**
+   * 自动压缩过长的对话（异步后台执行）
+   * 当对话消息数超过 12 条时触发 AI 摘要压缩
+   */
+  async #autoSummarize(conversationId) {
+    if (!this.#conversations || !this.#aiProvider) return;
+    try {
+      const messages = this.#conversations.load(conversationId, { tokenBudget: Infinity });
+      if (messages.length >= 12) {
+        await this.#conversations.summarize(conversationId, {
+          aiProvider: this.#aiProvider,
+        });
+      }
+    } catch {
+      // 摘要失败不影响主流程
+    }
+  }
+
   /**
    * 事件驱动入口（P2 预留接口）
    * @param {{ type: string, payload: object, source?: string }} event
@@ -800,7 +1000,7 @@ ${skillSection}
   async executeEvent(event) {
     const { type, payload } = event;
     const prompt = this.#eventToPrompt(type, payload);
-    return this.execute(prompt, { history: [] });
+    return this.execute(prompt, { history: [], source: 'system' });
   }
 
   #eventToPrompt(type, payload) {
@@ -816,6 +1016,54 @@ ${skillSection}
     }
   }
 
+  /**
+   * Context Window 自动压缩（受 Cline AutoCondense 启发）
+   *
+   * 在 ReAct 循环中实时检测消息总 token 数。
+   * 当超过 TOKEN_BUDGET 时，保留:
+   *   - 首条消息（可能是 system / 用户首问）
+   *   - 最后 4 条消息（当前推理上下文）
+   * 中间消息压缩为一条摘要。
+   *
+   * 策略: 非阻塞、纯规则（不调 AI），避免 ReAct 循环内引入额外 AI 调用。
+   */
+  #condenseIfNeeded(messages, tokenBudget = 10000) {
+    const estimateTokens = (text) => Math.ceil((text || '').length / 3.5);
+
+    let totalTokens = 0;
+    for (const m of messages) totalTokens += estimateTokens(m.content);
+
+    if (totalTokens <= tokenBudget || messages.length <= 6) return;
+
+    // 保留首条 + 最后 4 条，压缩中间
+    const keepTail = 4;
+    const first = messages[0];
+    const tail = messages.slice(-keepTail);
+    const middle = messages.slice(1, -keepTail);
+
+    if (middle.length === 0) return;
+
+    // 生成摘要
+    const toolCallSummary = middle
+      .filter(m => m.role === 'user' && m.content.startsWith('Observation from tool'))
+      .map(m => {
+        const toolMatch = m.content.match(/Observation from tool "([^"]+)"/);
+        return toolMatch ? toolMatch[1] : null;
+      })
+      .filter(Boolean);
+
+    const condensed = {
+      role: 'system',
+      content: `[上下文压缩] 省略了 ${middle.length} 条中间消息（含工具调用: ${toolCallSummary.join(', ') || '无'}）。请基于最近的 observation 继续推理。`,
+    };
+
+    // 原地修改数组
+    messages.length = 0;
+    messages.push(first, condensed, ...tail);
+
+    this.#logger.debug(`[ChatAgent] condensed ${middle.length} messages (${totalTokens} → ~${estimateTokens(first.content) + estimateTokens(condensed.content) + tail.reduce((s, m) => s + estimateTokens(m.content), 0)} tokens)`);
+  }
+
   /**
    * 截断长文本
    */