autosnippet 2.8.3 → 2.9.0

package/lib/service/chat/tools.js

@@ -123,30 +123,133 @@ function _scoreSearchLine(line) {
   return 0;
 }
 
+/**
+ * 收集项目文件列表 — 抽取为公用函数，供单次和批量搜索复用。
+ * 优先使用内存缓存（bootstrap 场景），否则从磁盘递归读取。
+ */
+async function _getProjectFiles(params, ctx) {
+  const { fileFilter } = params;
+  const projectRoot = ctx.projectRoot || process.cwd();
+
+  let extFilter = null;
+  if (fileFilter) {
+    const exts = fileFilter.split(',').map(e => e.trim().replace(/^\./, ''));
+    extFilter = new RegExp(`\\.(${exts.join('|')})$`, 'i');
+  }
+
+  const fileCache = ctx.fileCache || null;
+  let files;
+  let skippedThirdParty = 0;
+
+  if (fileCache && Array.isArray(fileCache)) {
+    files = fileCache.filter(f => {
+      const p = f.relativePath || f.path || '';
+      if (THIRD_PARTY_RE.test(p)) { skippedThirdParty++; return false; }
+      if (extFilter && !extFilter.test(p)) return false;
+      if (!SOURCE_EXT_RE.test(p)) return false;
+      return true;
+    });
+  } else {
+    files = [];
+    const MAX_FILE_SIZE = 512 * 1024;
+    const walk = (dir, relBase = '') => {
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const relPath = relBase ? `${relBase}/${entry.name}` : entry.name;
+          const fullPath = path.join(dir, entry.name);
+          const isDir = entry.isDirectory() || (entry.isSymbolicLink() && (() => { try { return fs.statSync(fullPath).isDirectory(); } catch { return false; } })());
+          const isFile = entry.isFile() || (entry.isSymbolicLink() && (() => { try { return fs.statSync(fullPath).isFile(); } catch { return false; } })());
+          if (isDir) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'build') continue;
+            if (THIRD_PARTY_RE.test(relPath + '/')) { skippedThirdParty++; continue; }
+            walk(fullPath, relPath);
+          } else if (isFile) {
+            if (THIRD_PARTY_RE.test(relPath)) { skippedThirdParty++; continue; }
+            if (!SOURCE_EXT_RE.test(entry.name)) continue;
+            if (extFilter && !extFilter.test(entry.name)) continue;
+            try {
+              const stat = fs.statSync(fullPath);
+              if (stat.size > MAX_FILE_SIZE) continue;
+              const content = fs.readFileSync(fullPath, 'utf-8');
+              files.push({ relativePath: relPath, content, name: entry.name });
+            } catch { /* skip unreadable files */ }
+          }
+        }
+      } catch { /* skip inaccessible dirs */ }
+    };
+    walk(projectRoot);
+  }
+
+  return { files, skippedThirdParty };
+}
+
 const searchProjectCode = {
   name: 'search_project_code',
   description: '在用户项目源码中搜索指定模式。返回匹配的代码片段及上下文。' +
     '自动过滤三方库代码（Pods/Carthage/node_modules），优先返回实际使用行而非声明行。' +
-    '适用场景：验证代码模式存在性、查找更多项目示例、理解项目中某个 API 的用法。',
+    '适用场景：验证代码模式存在性、查找更多项目示例、理解项目中某个 API 的用法。' +
+    '批量搜索：传入 patterns 数组可一次搜索多个关键词（每个关键词独立返回结果），减少工具调用次数。',
   parameters: {
     type: 'object',
     properties: {
-      pattern:      { type: 'string', description: '搜索词或正则表达式' },
+      pattern:      { type: 'string', description: '搜索词或正则表达式（单个搜索时使用）' },
+      patterns:     { type: 'array', items: { type: 'string' }, description: '批量搜索：多个搜索词数组，如 ["methodA", "methodB", "classC"]。与 pattern 互斥，优先使用 patterns。' },
       isRegex:      { type: 'boolean', description: '是否为正则表达式，默认 false' },
       fileFilter:   { type: 'string', description: '文件扩展名过滤，如 ".m,.swift"' },
-      contextLines: { type: 'number', description: '匹配行前后的上下文行数，默认 5' },
-      maxResults:   { type: 'number', description: '最大返回结果数，默认 8' },
+      contextLines: { type: 'number', description: '匹配行前后的上下文行数，默认 3' },
+      maxResults:   { type: 'number', description: '每个 pattern 的最大返回结果数，默认 5' },
     },
-    required: ['pattern'],
+    required: [],
   },
   handler: async (params, ctx) => {
+    // ── 去重缓存初始化 ──
+    const state = ctx._sharedState || ctx;
+    if (!state._searchCache) state._searchCache = new Map();
+
+    // ── 批量模式：patterns 数组 ──
+    if (Array.isArray(params.patterns) && params.patterns.length > 0) {
+      const batchPatterns = params.patterns.slice(0, 10); // 最多 10 个
+      const batchResults = {};
+      let dedupCount = 0;
+      for (const p of batchPatterns) {
+        // 去重：已搜索过的 pattern 直接返回缓存
+        const cacheKey = `${p}|${params.isRegex || false}|${params.fileFilter || ''}`;
+        if (state._searchCache.has(cacheKey)) {
+          batchResults[p] = { ...state._searchCache.get(cacheKey), _cached: true };
+          dedupCount++;
+          continue;
+        }
+        const sub = await searchProjectCode.handler(
+          { ...params, pattern: p, patterns: undefined },
+          ctx,
+        );
+        const entry = { matches: sub.matches || [], total: sub.total || 0 };
+        state._searchCache.set(cacheKey, entry);
+        batchResults[p] = entry;
+      }
+      return {
+        batchResults,
+        patternsSearched: batchPatterns.length,
+        searchedFiles: (await _getProjectFiles(params, ctx)).files.length,
+        ...(dedupCount > 0 ? { _deduped: dedupCount, hint: `${dedupCount} 个 pattern 命中缓存，请避免重复搜索相同关键词。` } : {}),
+      };
+    }
+
     // 兼容 AI 传 "query" / "search" / "keyword" 替代 "pattern"
     const pattern = params.pattern || params.query || params.search || params.keyword || params.search_query;
-    const { isRegex = false, fileFilter, contextLines = 5, maxResults = 8 } = params;
+    const { isRegex = false, fileFilter, contextLines = 3, maxResults = 5 } = params;
     const projectRoot = ctx.projectRoot || process.cwd();
 
     if (!pattern || typeof pattern !== 'string') {
-      return { error: '参数错误: 请提供 pattern（搜索关键词或正则表达式）', matches: [], total: 0 };
+      return { error: '参数错误: 请提供 pattern（搜索关键词或正则表达式）或 patterns 数组', matches: [], total: 0 };
+    }
+
+    // ── 单 pattern 去重检查 ──
+    const cacheKey = `${pattern}|${params.isRegex || false}|${params.fileFilter || ''}`;
+    if (state._searchCache.has(cacheKey)) {
+      const cached = state._searchCache.get(cacheKey);
+      return { ...cached, _cached: true, hint: `⚠ 已搜索过 "${pattern}"，返回缓存结果。请搜索不同的关键词以获取新信息。` };
     }
 
     // 构建搜索正则
@@ -157,61 +260,7 @@ const searchProjectCode = {
       return { error: `Invalid pattern: ${err.message}`, matches: [], total: 0 };
     }
 
-    // 文件扩展名过滤
-    let extFilter = null;
-    if (fileFilter) {
-      const exts = fileFilter.split(',').map(e => e.trim().replace(/^\./, ''));
-      extFilter = new RegExp(`\\.(${exts.join('|')})$`, 'i');
-    }
-
-    // 收集文件列表 — 优先使用内存缓存（bootstrap 场景），否则从磁盘递归读取
-    const fileCache = ctx.fileCache || null;
-    let files;
-    let skippedThirdParty = 0;
-
-    if (fileCache && Array.isArray(fileCache)) {
-      // Bootstrap 场景: allFiles 已在内存
-      files = fileCache.filter(f => {
-        const p = f.relativePath || f.path || '';
-        if (THIRD_PARTY_RE.test(p)) { skippedThirdParty++; return false; }
-        if (extFilter && !extFilter.test(p)) return false;
-        if (!SOURCE_EXT_RE.test(p)) return false;
-        return true;
-      });
-    } else {
-      // Dashboard / SignalCollector 场景: 从磁盘递归读取
-      files = [];
-      const MAX_FILE_SIZE = 512 * 1024; // 512KB — 跳过超大文件
-      const walk = (dir, relBase = '') => {
-        try {
-          const entries = fs.readdirSync(dir, { withFileTypes: true });
-          for (const entry of entries) {
-            const relPath = relBase ? `${relBase}/${entry.name}` : entry.name;
-            const fullPath = path.join(dir, entry.name);
-            // 支持 symlink: 解析为目录或文件
-            const isDir = entry.isDirectory() || (entry.isSymbolicLink() && (() => { try { return fs.statSync(fullPath).isDirectory(); } catch { return false; } })());
-            const isFile = entry.isFile() || (entry.isSymbolicLink() && (() => { try { return fs.statSync(fullPath).isFile(); } catch { return false; } })());
-            if (isDir) {
-              // 跳过隐藏目录和常见无关目录
-              if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'build') continue;
-              if (THIRD_PARTY_RE.test(relPath + '/')) { skippedThirdParty++; continue; }
-              walk(fullPath, relPath);
-            } else if (isFile) {
-              if (THIRD_PARTY_RE.test(relPath)) { skippedThirdParty++; continue; }
-              if (!SOURCE_EXT_RE.test(entry.name)) continue;
-              if (extFilter && !extFilter.test(entry.name)) continue;
-              try {
-                const stat = fs.statSync(fullPath);
-                if (stat.size > MAX_FILE_SIZE) continue; // 跳过超大文件
-                const content = fs.readFileSync(fullPath, 'utf-8');
-                files.push({ relativePath: relPath, content, name: entry.name });
-              } catch { /* skip unreadable files */ }
-            }
-          }
-        } catch { /* skip inaccessible dirs */ }
-      };
-      walk(projectRoot);
-    }
+    const { files, skippedThirdParty } = await _getProjectFiles(params, ctx);
 
     // 搜索匹配
     const matches = [];
@@ -253,21 +302,25 @@ const searchProjectCode = {
     // 按 score 降序排列（实际使用行优先）
     matches.sort((a, b) => b.score - a.score);
 
-    return {
+    const result = {
       matches,
       total,
       searchedFiles: files.length,
       skippedThirdParty,
       ...((() => {
         // P2.2: 搜索超限提示 — 引导使用 AST 工具
-        const state = ctx._sharedState || ctx;
         state._searchCallCount = (state._searchCallCount || 0) + 1;
-        if (state._searchCallCount > 8 && ctx.source === 'system') {
+        if (state._searchCallCount > 12 && ctx.source === 'system') {
           return { hint: `💡 你已搜索 ${state._searchCallCount} 次。考虑使用 get_class_info / get_class_hierarchy / get_project_overview 获取结构化信息，效率更高。` };
         }
         return {};
       })()),
     };
+
+    // 缓存搜索结果
+    state._searchCache.set(cacheKey, { matches: result.matches, total: result.total });
+
+    return result;
   },
 };
 
@@ -277,18 +330,51 @@ const searchProjectCode = {
 const readProjectFile = {
   name: 'read_project_file',
   description: '读取项目中指定文件的内容（部分或全部）。' +
-    '通常在 search_project_code 找到匹配后使用，获取更完整的上下文。',
+    '通常在 search_project_code 找到匹配后使用，获取更完整的上下文。' +
+    '批量读取：传入 filePaths 数组可一次读取多个文件，减少工具调用次数。',
   parameters: {
     type: 'object',
     properties: {
-      filePath:   { type: 'string', description: '相对于项目根目录的文件路径' },
+      filePath:   { type: 'string', description: '相对于项目根目录的文件路径（单个文件时使用）' },
+      filePaths:  { type: 'array', items: { type: 'string' }, description: '批量读取：多个文件路径数组。与 filePath 互斥，优先使用 filePaths。' },
       startLine:  { type: 'number', description: '起始行号（1-based），默认 1' },
       endLine:    { type: 'number', description: '结束行号（1-based），默认文件末尾' },
-      maxLines:   { type: 'number', description: '最大返回行数，默认 200' },
+      maxLines:   { type: 'number', description: '最大返回行数，默认 200（批量模式下每个文件最多 100 行）' },
     },
-    required: ['filePath'],
+    required: [],
   },
   handler: async (params, ctx) => {
+    // ── 去重缓存初始化 ──
+    const state = ctx._sharedState || ctx;
+    if (!state._readCache) state._readCache = new Map();
+
+    // ── 批量模式：filePaths 数组 ──
+    if (Array.isArray(params.filePaths) && params.filePaths.length > 0) {
+      const batchPaths = params.filePaths.slice(0, 8); // 最多 8 个文件
+      const batchResults = {};
+      let dedupCount = 0;
+      for (const fp of batchPaths) {
+        const cacheKey = `${fp}|${params.startLine || 1}|${params.endLine || ''}|${params.maxLines || 100}`;
+        if (state._readCache.has(cacheKey)) {
+          batchResults[fp] = { ...state._readCache.get(cacheKey), _cached: true };
+          dedupCount++;
+          continue;
+        }
+        const sub = await readProjectFile.handler(
+          { ...params, filePath: fp, filePaths: undefined, maxLines: Math.min(params.maxLines || 100, 100) },
+          ctx,
+        );
+        const entry = sub.error ? { error: sub.error } : { content: sub.content, totalLines: sub.totalLines, language: sub.language };
+        state._readCache.set(cacheKey, entry);
+        batchResults[fp] = entry;
+      }
+      return {
+        batchResults,
+        filesRead: batchPaths.length,
+        ...(dedupCount > 0 ? { _deduped: dedupCount, hint: `${dedupCount} 个文件命中缓存，请避免重复读取相同文件。` } : {}),
+      };
+    }
+
     // 兼容各种参数名变体 (ToolRegistry 层已做 snake→camel 归一化,
     // 这里兜底处理漏网之鱼)
     const filePath = params.filePath || params.path || params.file_path || params.filepath || params.file || params.filename;
@@ -296,7 +382,13 @@ const readProjectFile = {
     const projectRoot = ctx.projectRoot || process.cwd();
 
     if (!filePath || typeof filePath !== 'string') {
-      return { error: '参数错误: 请提供 filePath（相对于项目根目录的文件路径）' };
+      return { error: '参数错误: 请提供 filePath（相对于项目根目录的文件路径）或 filePaths 数组' };
+    }
+
+    // ── 单文件去重检查 ──
+    const readCacheKey = `${filePath}|${startLine}|${params.endLine || ''}|${maxLines}`;
+    if (state._readCache.has(readCacheKey)) {
+      return { ...state._readCache.get(readCacheKey), _cached: true, hint: `⚠ 已读取过该文件相同行范围，返回缓存结果。如需其他行范围请指定不同的 startLine/endLine。` };
     }
 
     // 安全检查: 禁止路径遍历
@@ -349,7 +441,7 @@ const readProjectFile = {
     const langMap = { '.m': 'objectivec', '.mm': 'objectivec', '.h': 'objectivec', '.swift': 'swift', '.js': 'javascript', '.ts': 'typescript', '.py': 'python', '.java': 'java', '.kt': 'kotlin', '.go': 'go', '.rs': 'rust', '.rb': 'ruby' };
     const language = langMap[ext] || 'unknown';
 
-    return {
+    const readResult = {
       filePath,
       totalLines,
       startLine: start,
@@ -357,6 +449,11 @@ const readProjectFile = {
       content: selectedLines.join('\n'),
       language,
     };
+
+    // 缓存读取结果
+    state._readCache.set(readCacheKey, { content: readResult.content, totalLines, language });
+
+    return readResult;
   },
 };
 

package/lib/service/skills/SignalCollector.js

@@ -128,8 +128,9 @@ export class SignalCollector {
       `[SignalCollector] started — mode=${this.#mode}, initialInterval=${this.#intervalMs}ms, AI-driven`
     );
 
-    // 首次延迟 15 秒后执行（等启动流程稳定）
-    this.#timer = setTimeout(() => this.#tick(), 15_000);
+    // 首次按正常间隔执行（不立即触发，避免启动时消耗 AI token）
+    // 如果有事件推送（EventAggregator batch），会提前触发
+    this.#timer = setTimeout(() => this.#tick(), this.#intervalMs);
   }
 
   stop() {

package/lib/service/spm/SpmService.js

@@ -7,8 +7,9 @@ import Logger from '../../infrastructure/logging/Logger.js';
 import { PackageSwiftParser } from './PackageSwiftParser.js';
 import { DependencyGraph } from './DependencyGraph.js';
 import { PolicyEngine } from './PolicyEngine.js';
+import { GraphCache } from '../../infrastructure/cache/GraphCache.js';
 import { dirname, relative, sep, resolve as pathResolve } from 'node:path';
-import { readFileSync, writeFileSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 
 export class SpmService {
   #parser;
@@ -35,6 +36,12 @@ export class SpmService {
    */
   #packageDepGraph;
 
+  /** @type {GraphCache} 磁盘缓存层 */
+  #graphCache;
+
+  /** @type {Map<string, object[]>} target 文件列表缓存 */
+  #targetFilesCache;
+
   constructor(projectRoot, options = {}) {
     this.#projectRoot = projectRoot;
     this.#aiFactory = options.aiFactory || null;
@@ -49,60 +56,92 @@ export class SpmService {
     this.#logger = Logger.getInstance();
     this.#targetPackageMap = new Map();
     this.#packageDepGraph = new Map();
+    this.#graphCache = new GraphCache(projectRoot);
+    this.#targetFilesCache = new Map();
   }
 
   /**
    * 加载并解析 Package.swift，构建依赖图
    * 支持多 Package 项目（如 BiliDemo 有多个子 Package）
+   * 优先从磁盘缓存加载（Package.swift contentHash 匹配即命中）
    */
   async load() {
     this.#targetPackageMap.clear();
     this.#packageDepGraph.clear();
+    this.#targetFilesCache.clear();
 
-    // 优先尝试根目录的 Package.swift
+    // ── 收集所有 Package.swift 路径 + 联合 hash ──
     const packagePath = this.#parser.findPackageSwift(this.#projectRoot);
+    const allPaths = packagePath ? [packagePath] : this.#parser.findAllPackageSwifts(this.#projectRoot);
+    if (allPaths.length === 0) {
+      this.#logger.warn('[SpmService] Package.swift 未找到');
+      return null;
+    }
+
+    const combinedHash = allPaths
+      .map(p => this.#graphCache.computeFileHash(p))
+      .join(':');
+
+    // ── 尝试命中缓存 ──
+    const cached = this.#graphCache.load('spm-graph');
+    if (cached && cached.contentHash === combinedHash) {
+      this.#restoreFromCache(cached.data);
+      this.#logger.info(`[SpmService] ⚡ 缓存命中 (${this.#graph.getNodes().length} targets, hash=${combinedHash.substring(0, 8)})`);
+      return cached.data.parsedResult;
+    }
+
+    // ── 缓存未命中，走完整解析 ──
+    const startTime = Date.now();
+    let parsedResult;
+
     if (packagePath) {
+      // 单包模式
       const parsed = this.#parser.parse(packagePath);
       this.#graph.buildFromParsed(parsed);
-      // 构建 target→package 映射
       for (const t of parsed.targets || []) {
         this.#targetPackageMap.set(t.name, { packageName: parsed.name, packagePath });
       }
-      // 构建包级依赖图（解析 .package(path: "...") 引用）
       this.#buildPackageDepGraph([{ path: packagePath, parsed }]);
       this.#logger.info(`[SpmService] 加载完成: ${parsed.name} (${parsed.targets.length} targets)`);
-      return parsed;
+      parsedResult = parsed;
+    } else {
+      // 多包模式
+      parsedResult = this.#loadMultiPackage(allPaths);
     }
 
-    // 没有根 Package.swift，扫描子目录中的所有 Package.swift
-    const allPaths = this.#parser.findAllPackageSwifts(this.#projectRoot);
-    if (allPaths.length === 0) {
-      this.#logger.warn('[SpmService] Package.swift 未找到');
-      return null;
+    // ── 写入缓存 ──
+    if (parsedResult) {
+      this.#saveToCache(combinedHash, parsedResult);
+      this.#logger.info(`[SpmService] 缓存已写入 (${Date.now() - startTime}ms 解析)`);
     }
 
+    return parsedResult;
+  }
+
+  /**
+   * 多包加载（从 load() 拆出）
+   * @param {string[]} allPaths Package.swift 路径数组
+   * @returns {object|null}
+   */
+  #loadMultiPackage(allPaths) {
     this.#logger.info(`[SpmService] 发现 ${allPaths.length} 个 Package.swift，逐一解析...`);
     let mergedTargets = [];
     let lastName = 'multi-package';
     const allParsed = [];
 
-    // 先清空图，然后逐个添加节点和边（不用 buildFromParsed 避免重复 clear）
     this.#graph.clear();
     for (const pkgPath of allPaths) {
       try {
         const parsed = this.#parser.parse(pkgPath);
         if (parsed) {
           allParsed.push({ path: pkgPath, parsed });
-          // 逐个添加 target 到图中
           for (const t of parsed.targets || []) {
             this.#graph.addNode(t.name);
             for (const dep of t.dependencies || []) {
               this.#graph.addEdge(t.name, dep);
             }
-            // 构建 target→package 映射
             this.#targetPackageMap.set(t.name, { packageName: parsed.name, packagePath: pkgPath });
           }
-          // 合并 target 列表（带 packageName 标记）
           for (const t of parsed.targets) {
             mergedTargets.push({
               ...t,
@@ -117,7 +156,6 @@ export class SpmService {
       }
     }
 
-    // 构建包级依赖图
     this.#buildPackageDepGraph(allParsed);
 
     this.#logger.info(`[SpmService] 多包加载完成: ${mergedTargets.length} targets from ${allPaths.length} packages`);
@@ -128,6 +166,51 @@ export class SpmService {
     };
   }
 
+  /**
+   * 将当前内存状态序列化到缓存
+   */
+  #saveToCache(contentHash, parsedResult) {
+    const graphJSON = this.#graph.toJSON();
+    const targetPackageEntries = [...this.#targetPackageMap.entries()];
+    const packageDepEntries = [...this.#packageDepGraph.entries()].map(
+      ([k, v]) => [k, [...v]]
+    );
+
+    this.#graphCache.save('spm-graph', {
+      parsedResult,
+      graphNodes: graphJSON.nodes,
+      graphEdges: graphJSON.edges,
+      targetPackageMap: targetPackageEntries,
+      packageDepGraph: packageDepEntries,
+    }, { contentHash });
+  }
+
+  /**
+   * 从缓存数据恢复内存状态
+   */
+  #restoreFromCache(data) {
+    // 恢复 DependencyGraph
+    this.#graph.clear();
+    for (const node of data.graphNodes || []) {
+      this.#graph.addNode(node);
+    }
+    for (const edge of data.graphEdges || []) {
+      this.#graph.addEdge(edge.from, edge.to);
+    }
+
+    // 恢复 targetPackageMap
+    this.#targetPackageMap.clear();
+    for (const [name, info] of data.targetPackageMap || []) {
+      this.#targetPackageMap.set(name, info);
+    }
+
+    // 恢复 packageDepGraph
+    this.#packageDepGraph.clear();
+    for (const [pkgPath, deps] of data.packageDepGraph || []) {
+      this.#packageDepGraph.set(pkgPath, new Set(deps));
+    }
+  }
+
   // ─────────────── 包级依赖图构建 ───────────────
 
   /**
@@ -585,14 +668,29 @@ export class SpmService {
    * 获取 Target 源文件列表（路由: POST /spm/target-files）
    * 支持多 Package 项目：先在 target 所属 package 目录查找
    * 支持非 SPM 项目：虚拟 directory target 直接扫描对应目录
+   * 使用内存缓存避免重复 fs walk
    */
   async getTargetFiles(target) {
-    const { existsSync, readdirSync, statSync } = await import('fs');
-    const { join, dirname, relative, extname } = await import('path');
-
     const targetName = typeof target === 'string' ? target : target?.name;
     if (!targetName) return [];
 
+    // 内存缓存命中
+    if (this.#targetFilesCache.has(targetName)) {
+      return this.#targetFilesCache.get(targetName);
+    }
+
+    const result = await this.#walkTargetFiles(target, targetName);
+    this.#targetFilesCache.set(targetName, result);
+    return result;
+  }
+
+  /**
+   * 实际的文件遍历逻辑（拆出以供缓存用）
+   */
+  async #walkTargetFiles(target, targetName) {
+    const { existsSync, readdirSync, statSync } = await import('fs');
+    const { join, dirname, relative, extname } = await import('path');
+
     // 判断是否为虚拟目录 target（非 SPM fallback）
     const isDirectoryTarget = typeof target === 'object' && target?.type === 'directory';
 
@@ -1103,8 +1201,11 @@ export class SpmService {
 
   /**
    * 刷新依赖映射（路由: POST /commands/spm-map）
+   * 会主动使缓存失效并重新解析
    */
   async updateDependencyMap(options = {}) {
+    this.#graphCache.invalidate('spm-graph');
+    this.#targetFilesCache.clear();
     this.#graph.clear();
     const parsed = await this.load();
     if (!parsed) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autosnippet",
-  "version": "2.8.3",
+  "version": "2.9.0",
   "description": "AutoSnippet - 连接开发者、AI 与项目知识库的工具",
   "type": "module",
   "main": "lib/bootstrap.js",