autosnippet 3.0.11 → 3.0.13

package/lib/service/guard/GuardPatternUtils.js

@@ -0,0 +1,180 @@
+/**
+ * GuardPatternUtils - Guard 模式匹配与掩码工具函数
+ *
+ * 从 GuardCheckEngine 拆分，包含:
+ * - compilePattern: 正则编译（带缓存）
+ * - clearPatternCache: 清除正则缓存
+ * - buildTestBlockMask: 测试块掩码（Rust #[cfg(test)]）
+ * - buildCommentMask: 注释行掩码
+ * - detectLanguage: 文件扩展名推断语言
+ */
+
+import { LanguageService } from '../../shared/LanguageService.js';
+
+/** @type {Map<string, RegExp>} 已编译的正则缓存 (pattern string → RegExp) */
+const _regexCache = new Map();
+
+/**
+ * 编译正则模式（支持 RegExp 对象和 string，带缓存）
+ * @param {RegExp|string} pattern
+ * @returns {RegExp}
+ */
+export function compilePattern(pattern) {
+  if (pattern instanceof RegExp) {
+    return pattern;
+  }
+  const key = String(pattern);
+  let cached = _regexCache.get(key);
+  if (!cached) {
+    cached = new RegExp(key);
+    _regexCache.set(key, cached);
+  }
+  return cached;
+}
+
+/**
+ * 清除正则缓存
+ */
+export function clearPatternCache() {
+  _regexCache.clear();
+}
+
+/**
+ * 构建内联测试块掩码
+ * 目前支持 Rust #[cfg(test)] mod xxx { ... } 块
+ * @param {string[]} lines
+ * @param {string} language
+ * @returns {boolean[]} 每行是否在测试块内
+ */
+export function buildTestBlockMask(lines, language) {
+  const mask = new Array(lines.length).fill(false);
+
+  // 目前仅 Rust 需要 — #[cfg(test)] 内联测试模块
+  if (language !== 'rust') return mask;
+
+  let inTestBlock = false;
+  let braceDepth = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trimStart();
+
+    if (!inTestBlock) {
+      // 检测 #[cfg(test)] 属性行
+      if (/^#\[cfg\(test\)\]/.test(trimmed)) {
+        // 向后找 mod xxx { — 标记为测试块起始
+        // 可能在同一行: #[cfg(test)] mod tests {
+        // 也可能在下一行: mod tests {
+        const restOfLine = trimmed.slice('#[cfg(test)]'.length).trim();
+        if (/^mod\s+\w+/.test(restOfLine)) {
+          // 同一行有 mod 声明
+          inTestBlock = true;
+          braceDepth = 0;
+          // 计算本行的花括号
+          for (const ch of lines[i]) {
+            if (ch === '{') braceDepth++;
+            else if (ch === '}') braceDepth--;
+          }
+          mask[i] = true;
+          if (braceDepth <= 0) inTestBlock = false; // 单行 mod 声明 (mod tests;)
+          continue;
+        }
+        // 检查下一行是否是 mod xxx {
+        if (i + 1 < lines.length && /^\s*mod\s+\w+/.test(lines[i + 1])) {
+          mask[i] = true; // #[cfg(test)] 行本身也标记
+          inTestBlock = true;
+          braceDepth = 0;
+          // 下一行会在循环中处理
+          continue;
+        }
+        // 单行 #[cfg(test)] 但后面不是 mod — 不处理
+      }
+    } else {
+      // 正在测试块内 — 追踪花括号深度
+      mask[i] = true;
+      for (const ch of lines[i]) {
+        if (ch === '{') braceDepth++;
+        else if (ch === '}') braceDepth--;
+      }
+      if (braceDepth <= 0) {
+        inTestBlock = false; // 测试块结束
+      }
+    }
+  }
+
+  return mask;
+}
+
+/**
+ * 构建注释行掩码 — 识别行注释和块注释内部行
+ *
+ * 支持的注释形式:
+ *   // 行注释,  /// 文档注释,  //! 内部文档注释  (C/Java/JS/TS/Go/Rust/Swift/Kotlin/Dart)
+ *   # 行注释  (Python)
+ *   /* ... * / 块注释  (C/Java/JS/TS/Go/Rust/Swift/Kotlin)
+ *   \"\"\" ... \"\"\"  (Python doc-string — 简化: 整行以 \"\"\" 开头的行)
+ *
+ * @param {string[]} lines
+ * @param {string} language
+ * @returns {boolean[]} 每行是否为注释行
+ */
+export function buildCommentMask(lines, language) {
+  const mask = new Array(lines.length).fill(false);
+  let inBlock = false; // 是否在 /* ... */ 块内
+
+  const usesHash = language === 'python'; // Python 用 # 注释
+  const usesSlash = !usesHash;            // 其他语言用 //
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trimStart();
+
+    // 块注释延续
+    if (inBlock) {
+      mask[i] = true;
+      if (trimmed.includes('*/')) {
+        inBlock = false;
+      }
+      continue;
+    }
+
+    // 块注释开始（同行不闭合）
+    if (usesSlash && /^\s*\/\*/.test(lines[i])) {
+      mask[i] = true;
+      if (!trimmed.includes('*/')) {
+        inBlock = true;
+      }
+      continue;
+    }
+
+    // 行注释: // 或 /// 或 //!
+    if (usesSlash && /^\s*\/\//.test(lines[i])) {
+      mask[i] = true;
+      continue;
+    }
+
+    // Python 行注释: #
+    if (usesHash && /^\s*#/.test(lines[i])) {
+      mask[i] = true;
+      continue;
+    }
+
+    // Python docstring 行 (简化: 整行以 """ 或 ''' 开头)
+    if (usesHash && /^\s*("""|''')/.test(lines[i])) {
+      mask[i] = true;
+      continue;
+    }
+  }
+
+  return mask;
+}
+
+/**
+ * 从文件扩展名推断语言
+ */
+export function detectLanguage(filePath) {
+  if (!filePath) {
+    return 'unknown';
+  }
+  const lang = LanguageService.inferLang(filePath);
+  // 向后兼容: Guard 内置规则使用 'objc' 而非 'objectivec'
+  return LanguageService.toGuardLangId(lang);
+}

package/lib/service/guard/GuardService.js

@@ -12,12 +12,18 @@ import { unixNow } from '../../shared/utils/common.js';
 export class GuardService {
   /**
    * @param {import('../../domain/knowledge/KnowledgeRepository.js').KnowledgeRepository} knowledgeRepository
+   * @param {object} auditLogger
+   * @param {object} gateway
+   * @param {object} [deps] - 可选依赖注入
+   * @param {import('./GuardCheckEngine.js').GuardCheckEngine} [deps.guardCheckEngine] - 核心引擎实例
    */
-  constructor(knowledgeRepository, auditLogger, gateway) {
+  constructor(knowledgeRepository, auditLogger, gateway, deps = {}) {
     this.knowledgeRepository = knowledgeRepository;
     this.auditLogger = auditLogger;
     this.gateway = gateway;
     this.logger = Logger.getInstance();
+    /** @type {import('./GuardCheckEngine.js').GuardCheckEngine|null} */
+    this._engine = deps.guardCheckEngine || null;
   }
 
   /**
@@ -152,7 +158,8 @@ export class GuardService {
 
   /**
    * 检查代码是否匹配 Guard 规则
-   * 查询所有 active 的 rule 实体的 constraints.guards[]
+   * 优先代理到 GuardCheckEngine（完整管线: 内置 + DB + EP + Code-Level + AST），
+   * 若引擎不可用则降级为仅 DB 规则的简化检查
    */
   async checkCode(code, options = {}) {
     try {
@@ -162,51 +169,86 @@ export class GuardService {
 
       const { language = null } = options;
 
-      // V3: 使用 findActiveRules() 查询 kind='rule' + lifecycle='active'
-      let guardEntries = await this.knowledgeRepository.findActiveRules();
-
-      // 按语言过滤
-      if (language) {
-        guardEntries = guardEntries.filter((e) => !e.language || e.language === language);
-      }
-
-      const matches = [];
-      for (const entry of guardEntries) {
-        const guards = entry.constraints?.guards || [];
-        for (const guard of guards) {
-          try {
-            const regex = new RegExp(guard.pattern, 'gm');
-            const codeMatches = [...code.matchAll(regex)];
-            if (codeMatches.length > 0) {
-              matches.push({
-                ruleId: entry.id,
-                ruleName: entry.title,
-                severity: guard.severity || 'warning',
-                message: guard.message || '',
-                matches: codeMatches.map((m) => ({
-                  match: m[0],
-                  index: m.index,
-                  line: code.substring(0, m.index).split('\\n').length,
-                })),
-                matchCount: codeMatches.length,
-              });
-            }
-          } catch (e) {
-            this.logger.warn('Error matching guard pattern', {
-              entryId: entry.id,
-              error: e.message,
-            });
-          }
+      // ── 优先路径: 代理到 GuardCheckEngine（完整管线）──
+      if (this._engine) {
+        try {
+          const violations = this._engine.checkCode(code, language || 'unknown', {
+            scope: 'file',
+          });
+          return violations.map((v) => ({
+            ruleId: v.ruleId,
+            ruleName: v.ruleId,
+            severity: v.severity || 'warning',
+            message: v.message || '',
+            line: v.line,
+            snippet: v.snippet,
+            matchCount: 1,
+            ...(v.fixSuggestion ? { fixSuggestion: v.fixSuggestion } : {}),
+            ...(v.reasoning ? { reasoning: v.reasoning } : {}),
+          }));
+        } catch (engineErr) {
+          this.logger.debug('GuardCheckEngine.checkCode failed, falling back to DB-only check', {
+            error: engineErr.message,
+          });
         }
       }
 
-      return matches;
+      // ── 降级路径: 仅 DB 规则简化检查 ──
+      return this._checkCodeDbOnly(code, { language });
     } catch (error) {
       this.logger.error('Error checking code against rules', { error: error.message });
       throw error;
     }
   }
 
+  /**
+   * 仅 DB 规则的简化检查（降级路径）
+   * @private
+   */
+  async _checkCodeDbOnly(code, options = {}) {
+    const { language = null } = options;
+
+    // V3: 使用 findActiveRules() 查询 kind='rule' + lifecycle='active'
+    let guardEntries = await this.knowledgeRepository.findActiveRules();
+
+    // 按语言过滤
+    if (language) {
+      guardEntries = guardEntries.filter((e) => !e.language || e.language === language);
+    }
+
+    const matches = [];
+    for (const entry of guardEntries) {
+      const guards = entry.constraints?.guards || [];
+      for (const guard of guards) {
+        try {
+          const regex = new RegExp(guard.pattern, 'gm');
+          const codeMatches = [...code.matchAll(regex)];
+          if (codeMatches.length > 0) {
+            matches.push({
+              ruleId: entry.id,
+              ruleName: entry.title,
+              severity: guard.severity || 'warning',
+              message: guard.message || '',
+              matches: codeMatches.map((m) => ({
+                match: m[0],
+                index: m.index,
+                line: code.substring(0, m.index).split('\\n').length,
+              })),
+              matchCount: codeMatches.length,
+            });
+          }
+        } catch (e) {
+          this.logger.warn('Error matching guard pattern', {
+            entryId: entry.id,
+            error: e.message,
+          });
+        }
+      }
+    }
+
+    return matches;
+  }
+
   /**
    * 查询规则列表 (kind='rule' + knowledgeType='boundary-constraint')
    */

package/lib/service/module/ModuleService.js

@@ -313,6 +313,7 @@ export class ModuleService {
 
     return {
       projectRoot: this.#projectRoot,
+      projectName: _pathBasename(this.#projectRoot) || '',
       primaryLanguage: primaryDiscoverer
         ? this.#discovererToLanguage(primaryDiscoverer.id)
         : 'unknown',

package/lib/service/search/SearchEngine.js

@@ -659,7 +659,7 @@ export class SearchEngine {
   }
 
   /**
-   * 补充详细字段（content / description / trigger）— 批量 IN 查询
+   * 补充详细字段（content / description / trigger / delivery 字段）— 批量 IN 查询
    * 用于向量搜索结果与 BM25 结果的一致性
    */
   _supplementDetails(items) {
@@ -674,7 +674,8 @@ export class SearchEngine {
         rows = this.db
           .prepare(
             `SELECT id, content, description, trigger, headers, moduleName,
-                  tags, language, category, updatedAt, createdAt, quality, stats, difficulty
+                  tags, language, category, updatedAt, createdAt, quality, stats, difficulty,
+                  whenClause, doClause
            FROM knowledge_entries WHERE id IN (${placeholders})`
           )
           .all(...ids);
@@ -694,6 +695,13 @@ export class SearchEngine {
           if (row.moduleName) {
             item.moduleName = row.moduleName;
           }
+          // Cursor 交付字段 — 供 Agent 投影生成 actionHint
+          if (!item.whenClause && row.whenClause) {
+            item.whenClause = row.whenClause;
+          }
+          if (!item.doClause && row.doClause) {
+            item.doClause = row.doClause;
+          }
           // 排序信号补充 — 确保 Funnel/Ranker 有真实数据
           if (!item.language && row.language) {
             item.language = row.language;