autosnippet 2.5.0 → 2.7.0

package/lib/service/chat/ConversationStore.js

@@ -0,0 +1,377 @@
+/**
+ * ConversationStore — 对话持久化 + 上下文窗口管理
+ *
+ * 设计:
+ * - 每个对话一个 JSONL 文件: .autosnippet/conversations/{id}.jsonl
+ * - 索引文件: .autosnippet/conversations/index.json
+ * - 按 category 隔离: 'user'(Dashboard) / 'system'(SignalCollector)
+ * - Token 预算: 超限时自动生成摘要压缩旧轮次
+ * - 静默降级: 持久化失败不影响核心功能
+ *
+ * Token 计算策略:
+ *   采用字符数近似估算 (1 token ≈ 3.5 字符中文 / ≈ 4 字符英文)
+ *   简单高效，无需额外依赖
+ *
+ * 文件结构:
+ *   .autosnippet/conversations/
+ *     index.json   — 对话元数据索引
+ *     {id}.jsonl   — 每行一条消息 {role, content, ts}
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import Logger from '../../infrastructure/logging/Logger.js';
+
+const DEFAULT_TOKEN_BUDGET = 12000;     // ~12K tokens 留给历史, 其余给系统提示词和当前消息
+const CHARS_PER_TOKEN = 3.5;            // 近似: 中文 ~3.5 / 英文 ~4 / 取偏保守值
+const MAX_CONVERSATIONS = 100;          // 索引最多保留 100 个对话
+const SUMMARY_TARGET_TOKENS = 500;      // 压缩后的摘要目标 token 数
+
+export class ConversationStore {
+  #dir;
+  #indexPath;
+  #logger;
+
+  /**
+   * @param {string} projectRoot — 用户项目根目录
+   */
+  constructor(projectRoot) {
+    this.#dir = path.join(projectRoot, '.autosnippet', 'conversations');
+    this.#indexPath = path.join(this.#dir, 'index.json');
+    this.#logger = Logger.getInstance();
+  }
+
+  // ═══════════════════════════════════════════════════════
+  //  公共 API
+  // ═══════════════════════════════════════════════════════
+
+  /**
+   * 创建新对话
+   * @param {object} opts
+   * @param {'user'|'system'} opts.category — 对话类别
+   * @param {string} [opts.title] — 对话标题
+   * @returns {string} conversationId
+   */
+  create({ category = 'user', title = '' } = {}) {
+    const id = crypto.randomUUID();
+    const entry = {
+      id,
+      category,
+      title,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      messageCount: 0,
+      hasSummary: false,
+    };
+
+    const index = this.#loadIndex();
+    index.unshift(entry);
+
+    // 限制索引大小
+    if (index.length > MAX_CONVERSATIONS) {
+      const removed = index.splice(MAX_CONVERSATIONS);
+      // 清理旧对话文件
+      for (const old of removed) {
+        this.#deleteConversationFile(old.id);
+      }
+    }
+
+    this.#saveIndex(index);
+    return id;
+  }
+
+  /**
+   * 追加消息到对话
+   * @param {string} conversationId
+   * @param {{ role: string, content: string }} message
+   */
+  append(conversationId, message) {
+    try {
+      fs.mkdirSync(this.#dir, { recursive: true });
+      const filePath = this.#conversationPath(conversationId);
+      const line = JSON.stringify({
+        role: message.role,
+        content: message.content,
+        ts: new Date().toISOString(),
+      });
+      fs.appendFileSync(filePath, line + '\n', 'utf-8');
+
+      // 更新索引
+      const index = this.#loadIndex();
+      const entry = index.find(e => e.id === conversationId);
+      if (entry) {
+        entry.updatedAt = new Date().toISOString();
+        entry.messageCount = (entry.messageCount || 0) + 1;
+        // 用首条用户消息作为标题
+        if (!entry.title && message.role === 'user') {
+          entry.title = message.content.substring(0, 60);
+        }
+        this.#saveIndex(index);
+      }
+    } catch (err) {
+      this.#logger.warn(`[ConversationStore] append failed: ${err.message}`);
+    }
+  }
+
+  /**
+   * 加载对话历史（带 token 预算控制）
+   *
+   * 如果历史超出 tokenBudget:
+   *   - 保留开头的摘要（如有）
+   *   - 截断中间的旧消息
+   *   - 保留最新的消息
+   *
+   * @param {string} conversationId
+   * @param {object} [opts]
+   * @param {number} [opts.tokenBudget] — token 预算
+   * @returns {{ role: string, content: string }[]}
+   */
+  load(conversationId, { tokenBudget = DEFAULT_TOKEN_BUDGET } = {}) {
+    try {
+      const filePath = this.#conversationPath(conversationId);
+      if (!fs.existsSync(filePath)) return [];
+
+      const raw = fs.readFileSync(filePath, 'utf-8').trim();
+      if (!raw) return [];
+
+      const messages = raw.split('\n')
+        .filter(Boolean)
+        .map(line => {
+          try {
+            const parsed = JSON.parse(line);
+            return { role: parsed.role, content: parsed.content };
+          } catch { return null; }
+        })
+        .filter(Boolean);
+
+      return this.#fitWithinBudget(messages, tokenBudget);
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * 对话列表
+   * @param {object} [opts]
+   * @param {'user'|'system'} [opts.category] — 按类别过滤
+   * @param {number} [opts.limit=20]
+   * @returns {Array}
+   */
+  list({ category, limit = 20 } = {}) {
+    const index = this.#loadIndex();
+    let results = index;
+    if (category) {
+      results = results.filter(e => e.category === category);
+    }
+    return results.slice(0, limit);
+  }
+
+  /**
+   * 删除对话
+   * @param {string} conversationId
+   */
+  delete(conversationId) {
+    this.#deleteConversationFile(conversationId);
+    const index = this.#loadIndex();
+    const filtered = index.filter(e => e.id !== conversationId);
+    this.#saveIndex(filtered);
+  }
+
+  /**
+   * 为对话生成压缩摘要（需要 AI）
+   * 将旧消息替换为一条 system 摘要消息
+   *
+   * @param {string} conversationId
+   * @param {object} opts
+   * @param {object} opts.aiProvider — AI Provider 实例
+   * @returns {Promise<boolean>} 是否成功压缩
+   */
+  async summarize(conversationId, { aiProvider }) {
+    if (!aiProvider) return false;
+
+    try {
+      const filePath = this.#conversationPath(conversationId);
+      if (!fs.existsSync(filePath)) return false;
+
+      const raw = fs.readFileSync(filePath, 'utf-8').trim();
+      if (!raw) return false;
+
+      const messages = raw.split('\n')
+        .filter(Boolean)
+        .map(line => { try { return JSON.parse(line); } catch { return null; } })
+        .filter(Boolean);
+
+      if (messages.length < 6) return false; // 太短不需要压缩
+
+      // 保留最近 4 条消息，压缩其余
+      const toSummarize = messages.slice(0, -4);
+      const toKeep = messages.slice(-4);
+
+      const summaryPrompt = `请用 2-3 句话总结以下对话的要点（保留关键决策、用户偏好、操作结果）：\n\n${
+        toSummarize.map(m => `[${m.role}] ${m.content}`).join('\n').substring(0, 4000)
+      }`;
+
+      const summary = await aiProvider.chat(summaryPrompt, {
+        temperature: 0.3,
+        maxTokens: 300,
+      });
+
+      if (!summary) return false;
+
+      // 重写对话文件: 摘要 + 最近消息
+      const newMessages = [
+        { role: 'system', content: `[对话摘要] ${summary.trim()}`, ts: new Date().toISOString() },
+        ...toKeep,
+      ];
+
+      fs.writeFileSync(
+        filePath,
+        newMessages.map(m => JSON.stringify(m)).join('\n') + '\n',
+        'utf-8',
+      );
+
+      // 更新索引
+      const index = this.#loadIndex();
+      const entry = index.find(e => e.id === conversationId);
+      if (entry) {
+        entry.hasSummary = true;
+        entry.messageCount = newMessages.length;
+        this.#saveIndex(index);
+      }
+
+      this.#logger.info(`[ConversationStore] summarized conversation ${conversationId}: ${messages.length} → ${newMessages.length} messages`);
+      return true;
+    } catch (err) {
+      this.#logger.warn(`[ConversationStore] summarize failed: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 清理过期对话
+   * @param {object} [opts]
+   * @param {number} [opts.maxAgeDays=30] — 超过此天数的对话将被删除
+   * @param {'user'|'system'} [opts.category] — 只清理特定类别
+   * @returns {{ deleted: number }}
+   */
+  cleanup({ maxAgeDays = 30, category } = {}) {
+    const index = this.#loadIndex();
+    const cutoff = Date.now() - maxAgeDays * 86400000;
+    let deleted = 0;
+
+    const kept = index.filter(entry => {
+      if (category && entry.category !== category) return true;
+      const updatedAt = new Date(entry.updatedAt).getTime();
+      if (updatedAt < cutoff) {
+        this.#deleteConversationFile(entry.id);
+        deleted++;
+        return false;
+      }
+      return true;
+    });
+
+    if (deleted > 0) {
+      this.#saveIndex(kept);
+      this.#logger.info(`[ConversationStore] cleaned up ${deleted} old conversations`);
+    }
+
+    return { deleted };
+  }
+
+  /**
+   * 估算 token 数
+   * @param {string} text
+   * @returns {number}
+   */
+  estimateTokens(text) {
+    if (!text) return 0;
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+  }
+
+  // ═══════════════════════════════════════════════════════
+  //  内部方法
+  // ═══════════════════════════════════════════════════════
+
+  /**
+   * 将消息列表裁剪到 token 预算内
+   * 策略: 保留首条摘要(如有) + 最新消息，丢弃中间旧消息
+   */
+  #fitWithinBudget(messages, tokenBudget) {
+    if (messages.length === 0) return [];
+
+    // 计算总 token
+    let totalTokens = 0;
+    const tokenCounts = messages.map(m => {
+      const tokens = this.estimateTokens(m.content);
+      totalTokens += tokens;
+      return tokens;
+    });
+
+    if (totalTokens <= tokenBudget) return messages;
+
+    // 超预算 — 保留首条(摘要) + 从末尾往前取
+    const result = [];
+    let used = 0;
+
+    // 如果首条是 system 摘要，优先保留
+    if (messages[0].role === 'system' && messages[0].content.startsWith('[对话摘要]')) {
+      result.push(messages[0]);
+      used += tokenCounts[0];
+    }
+
+    // 从末尾往前填充
+    const tail = [];
+    for (let i = messages.length - 1; i >= (result.length > 0 ? 1 : 0); i--) {
+      if (used + tokenCounts[i] > tokenBudget) break;
+      tail.unshift(messages[i]);
+      used += tokenCounts[i];
+    }
+
+    // 如果丢弃了消息，插入提示
+    const keptFromStart = result.length;
+    const keptFromEnd = tail.length;
+    const dropped = messages.length - keptFromStart - keptFromEnd;
+
+    if (dropped > 0) {
+      result.push({
+        role: 'system',
+        content: `[上下文截断] 省略了 ${dropped} 条较早的消息以适应上下文窗口。`,
+      });
+    }
+
+    result.push(...tail);
+    return result;
+  }
+
+  #conversationPath(id) {
+    return path.join(this.#dir, `${id}.jsonl`);
+  }
+
+  #deleteConversationFile(id) {
+    try {
+      const filePath = this.#conversationPath(id);
+      if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+    } catch { /* ignore */ }
+  }
+
+  #loadIndex() {
+    try {
+      if (fs.existsSync(this.#indexPath)) {
+        return JSON.parse(fs.readFileSync(this.#indexPath, 'utf-8'));
+      }
+    } catch { /* corrupt — reset */ }
+    return [];
+  }
+
+  #saveIndex(index) {
+    try {
+      fs.mkdirSync(this.#dir, { recursive: true });
+      fs.writeFileSync(this.#indexPath, JSON.stringify(index, null, 2), 'utf-8');
+    } catch (err) {
+      this.#logger.warn(`[ConversationStore] index save failed: ${err.message}`);
+    }
+  }
+}
+
+export default ConversationStore;

package/lib/service/chat/HandoffProtocol.js

@@ -0,0 +1,180 @@
+/**
+ * HandoffProtocol.js — Analyst → Producer 交接协议
+ *
+ * 职责:
+ * 1. 从 Analyst 执行结果构建 AnalysisReport
+ * 2. 质量门控: 判断分析是否足够深入
+ * 3. 提供重试提示构建
+ *
+ * @module HandoffProtocol
+ */
+
+// ──────────────────────────────────────────────────────────────────
+// AnalysisReport 构建
+// ──────────────────────────────────────────────────────────────────
+
+/**
+ * 从 Analyst 的执行结果构建 AnalysisReport
+ *
+ * @param {object} analystResult — ChatAgent.execute() 返回值
+ * @param {string} analystResult.reply — Analyst 的自然语言分析文本
+ * @param {Array} analystResult.toolCalls — 工具调用记录
+ * @param {string} dimensionId — 维度 ID
+ * @param {object} [projectGraph] — ProjectGraph 实例 (用于从 className 反查文件路径)
+ * @returns {AnalysisReport}
+ */
+export function buildAnalysisReport(analystResult, dimensionId, projectGraph = null) {
+  const referencedFiles = new Set();
+  const searchQueries = [];
+  const classesExplored = [];
+
+  for (const call of (analystResult.toolCalls || [])) {
+    const tool = call.tool || call.name;
+    const args = call.params || call.args || {};
+    const result = call.result;
+
+    switch (tool) {
+      case 'read_project_file':
+        if (args.filePath) referencedFiles.add(args.filePath);
+        break;
+      case 'search_project_code':
+        if (args.pattern || args.query) searchQueries.push(args.pattern || args.query);
+        // 从搜索结果中提取文件路径
+        if (typeof result === 'string') {
+          const fileMatches = result.match(/(?:^|\n)([\w/.-]+\.[mhswift]+)(?::\d+)?/g);
+          if (fileMatches) {
+            for (const m of fileMatches) {
+              const clean = m.trim().replace(/:\d+$/, '').replace(/^\n/, '');
+              if (clean.length > 2 && clean.length < 120) referencedFiles.add(clean);
+            }
+          }
+        }
+        break;
+      case 'get_class_info':
+        if (args.className) {
+          classesExplored.push(args.className);
+          // 从 ProjectGraph 反查文件路径
+          if (projectGraph) {
+            const info = projectGraph.getClassInfo(args.className);
+            if (info?.filePath) referencedFiles.add(info.filePath);
+          }
+        }
+        break;
+      case 'get_protocol_info':
+        if (args.protocolName && projectGraph) {
+          const info = projectGraph.getProtocolInfo(args.protocolName);
+          if (info?.filePath) referencedFiles.add(info.filePath);
+        }
+        break;
+      case 'get_file_summary':
+        if (args.filePath) referencedFiles.add(args.filePath);
+        break;
+    }
+  }
+
+  // 从分析文本中提取文件路径
+  const text = analystResult.reply || '';
+  const textFileRefs = text.match(/[\w/.-]+\.[mhswift]+/g);
+  if (textFileRefs) {
+    for (const f of textFileRefs) {
+      if (f.length > 2 && f.length < 120 && /\.[mhswift]+$/.test(f)) {
+        referencedFiles.add(f);
+      }
+    }
+  }
+
+  return {
+    analysisText: text,
+    referencedFiles: [...referencedFiles],
+    searchQueries,
+    classesExplored,
+    dimensionId,
+    metadata: {
+      iterations: analystResult.toolCalls?.length || 0,
+      toolCallCount: analystResult.toolCalls?.length || 0,
+    },
+  };
+}
+
+// ──────────────────────────────────────────────────────────────────
+// 质量门控 (Gate)
+// ──────────────────────────────────────────────────────────────────
+
+/**
+ * 分析质量门控 — 判断 Analyst 的输出是否足够好
+ *
+ * @param {AnalysisReport} report
+ * @param {object} [options]
+ * @param {string} [options.outputType] — 'analysis' | 'dual' | 'candidate'
+ * @returns {{ pass: boolean, reason?: string, action?: 'retry' | 'degrade' }}
+ */
+export function analysisQualityGate(report, options = {}) {
+  const needsCandidates = options.outputType === 'dual' || options.outputType === 'candidate';
+  // 需要产出候选的维度要求更高门槛
+  const minChars = needsCandidates ? 400 : 200;
+  const minFileRefs = needsCandidates ? 3 : 2;
+
+  // 规则 1: 最少字符数 — 分析太短说明未充分探索
+  if (report.analysisText.length < minChars) {
+    return { pass: false, reason: 'Analysis too short', action: 'retry' };
+  }
+
+  // 规则 2: 最少引用文件数 — 未引用文件说明未看代码
+  if (report.referencedFiles.length < minFileRefs) {
+    return { pass: false, reason: 'Too few file references', action: 'retry' };
+  }
+
+  // 规则 3: 检测"拒绝回答"模式
+  const refusalPatterns = [
+    /I cannot|I'm unable|I don't have access/i,
+    /无法分析|无法访问|没有足够/,
+  ];
+  if (refusalPatterns.some(p => p.test(report.analysisText))) {
+    return { pass: false, reason: 'Agent refused to analyze', action: 'degrade' };
+  }
+
+  // 规则 4: 内容实质性检查 — 有结构化内容或足够多的探索
+  // v3.1: 放宽条件 — tool calling 模式下 AI 往往不输出 markdown 格式
+  // 只要分析足够长且引用了足够多的文件，就认为有实质性内容
+  const hasStructure = /#{1,3}\s/.test(report.analysisText) ||
+                       /\d+\.\s/.test(report.analysisText) ||
+                       /[-•]\s/.test(report.analysisText) ||
+                       /[：:].+\n/.test(report.analysisText) ||
+                       report.analysisText.length >= 500 ||
+                       (report.referencedFiles.length >= 3 && report.analysisText.length >= 200);
+  if (!hasStructure) {
+    return { pass: false, reason: 'Analysis lacks structure', action: 'retry' };
+  }
+
+  return { pass: true };
+}
+
+/**
+ * 构建重试提示 — Gate 失败时给 Analyst 的追加指令
+ *
+ * @param {string} reason — Gate 失败原因
+ * @returns {string}
+ */
+export function buildRetryPrompt(reason) {
+  const hints = {
+    'Analysis too short': '你的分析不够深入。请使用更多工具（get_class_info、read_project_file、search_project_code）查看实际代码，输出至少 500 字的分析。',
+    'Too few file references': '你的分析缺少代码引用。请使用 get_class_info 和 read_project_file 查看至少 3 个相关文件，并在分析中引用具体文件和行号。',
+    'Analysis lacks structure': '请将分析组织成结构化的段落，使用编号列表或标题来区分不同的发现。每个发现应包含具体的文件路径和代码位置。',
+  };
+
+  return hints[reason] || '请更深入地分析代码，引用至少 3 个具体文件，每个发现都要有代码证据。';
+}
+
+// ──────────────────────────────────────────────────────────────────
+// 类型定义 (JSDoc)
+// ──────────────────────────────────────────────────────────────────
+
+/**
+ * @typedef {object} AnalysisReport
+ * @property {string} analysisText — Analyst 的完整回复文本
+ * @property {string[]} referencedFiles — 从 toolCalls 中提取的已引用文件路径
+ * @property {string[]} searchQueries — 从 toolCalls 中提取的搜索查询
+ * @property {string[]} classesExplored — 从 toolCalls 中提取的已查看类名
+ * @property {string} dimensionId — 维度 ID
+ * @property {object} metadata — { iterations, toolCallCount }
+ */

package/lib/service/chat/Memory.js

@@ -1,17 +1,24 @@
 /**
- * Memory — 跨对话轻量记忆
+ * Memory — 跨对话轻量记忆（带 source 隔离 + 去重）
  *
  * 设计:
  * - JSONL 文件存储，每行一条记忆
  * - 支持 TTL 自动过期
  * - 上限 maxEntries，超出时截断旧条目
  * - 读写均做静默降级（Memory 是增强，不是核心路径）
+ * - source 标签: 'user'(用户对话) / 'system'(SignalCollector 等后台)
+ * - 去重: 相同 type+content 的记忆不重复写入
  *
  * 记忆类型:
  * - preference: 用户偏好（"我们不用 singleton"、"以后用 DI"）
  * - decision:   关键决策（"Network 模块审核通过"）
  * - context:    项目上下文（"主语言是 Swift，使用 SPM"）
  *
+ * 隔离规则:
+ *   toPromptSection({ source }) 可按 source 过滤
+ *   用户对话只看 source=user 的记忆
+ *   系统分析可看全部记忆
+ *
  * 文件路径: .autosnippet/memory.jsonl
  */
 
@@ -35,9 +42,11 @@ export class Memory {
   /**
    * 读取最近 N 条记忆，过滤过期项
    * @param {number} [limit=20]
-   * @returns {{ ts: string, type: string, content: string, ttl?: number }[]}
+   * @param {object} [opts]
+   * @param {'user'|'system'} [opts.source] — 按 source 过滤
+   * @returns {{ ts: string, type: string, content: string, source?: string, ttl?: number }[]}
    */
-  load(limit = 20) {
+  load(limit = 20, { source } = {}) {
     try {
       if (!fs.existsSync(this.#filePath)) return [];
       const raw = fs.readFileSync(this.#filePath, 'utf-8').trim();
@@ -48,6 +57,7 @@ export class Memory {
         .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)
+        .filter(m => !source || (m.source || 'user') === source)
         .slice(-limit);
     } catch {
       return [];
@@ -55,14 +65,27 @@ export class Memory {
   }
 
   /**
-   * 追加一条记忆
-   * @param {{ type: string, content: string, ttl?: number }} entry
+   * 追加一条记忆（自动去重）
+   * @param {{ type: string, content: string, source?: string, ttl?: number }} entry
    */
   append(entry) {
     try {
+      // 去重: 检查是否已有相同 type+content 的记忆
+      const existing = this.load(this.#maxEntries);
+      const normalizedContent = (entry.content || '').trim().substring(0, 200);
+      const isDuplicate = existing.some(
+        m => m.type === entry.type && m.content === normalizedContent,
+      );
+      if (isDuplicate) return;
+
       const dir = path.dirname(this.#filePath);
       fs.mkdirSync(dir, { recursive: true });
-      const line = JSON.stringify({ ts: new Date().toISOString(), ...entry });
+      const line = JSON.stringify({
+        ts: new Date().toISOString(),
+        source: entry.source || 'user',
+        ...entry,
+        content: normalizedContent,
+      });
       fs.appendFileSync(this.#filePath, line + '\n', 'utf-8');
       this.#compact();
     } catch { /* write failure non-critical */ }
@@ -70,10 +93,15 @@ export class Memory {
 
   /**
    * 生成供系统提示词的记忆摘要
+   *
+   * @param {object} [opts]
+   * @param {'user'|'system'} [opts.source] — 只包含指定 source 的记忆
+   *   - 用户对话建议传 'user' 避免系统分析记忆污染
+   *   - 后台分析可传 undefined 获取全部
    * @returns {string}
    */
-  toPromptSection() {
-    const memories = this.load();
+  toPromptSection({ source } = {}) {
+    const memories = this.load(20, { source });
     if (memories.length === 0) return '';
     const lines = memories.map(m => `- [${m.type}] ${m.content}`).join('\n');
     return `\n## 历史记忆\n以下是之前对话中积累的项目偏好和决策，请参考：\n${lines}\n`;
@@ -81,9 +109,11 @@ export class Memory {
 
   /**
    * 当前记忆条数
+   * @param {object} [opts]
+   * @param {'user'|'system'} [opts.source]
    */
-  get size() {
-    return this.load(this.#maxEntries).length;
+  size({ source } = {}) {
+    return this.load(this.#maxEntries, { source }).length;
   }
 
   /**