autosnippet 3.0.10 → 3.0.13

package/lib/service/cursor/KnowledgeCompressor.js

@@ -1,16 +1,53 @@
 /**
- * KnowledgeCompressor — 知识条目压缩器（v2 无降级版）
+ * KnowledgeCompressor — 知识条目压缩器（v3 优化版）
  *
  * 将 KnowledgeEntry（含 AI 预计算字段）格式化为 Cursor 交付格式：
- *   - Channel A: compressToRuleLine() → 一行式强制规则
- *   - Channel B: compressToWhenDoDont() → When/Do/Don't + Template 格式
+ *   - Channel A: compressToRuleLine() → 一行式强制规则（含可选 language 前缀）
+ *   - Channel B: compressToWhenDoDont() → When/Do/Don't/Why + Template 格式
  *
  * 原则：只做格式化，无字段 = 不输出，不做启发式猜测。
+ *
+ * v3 变更:
+ *   - Channel A: 多语言项目中增加 [language] 前缀
+ *   - Channel B: 增加 Why 行（content.rationale 首句）
+ *   - Channel B: coreCode 骨架化（去注释 + 截断 ≤15 行）
  */
 
+/** 从 rationale 提取首句（≤120 字符），用于 Channel B 的 Why 行 */
+function _extractFirstSentence(rationale) {
+  if (!rationale) return '';
+  // 优先按句号或换行分割
+  const first = rationale.split(/[.\n。！？!?]/)[0]?.trim();
+  if (!first) return '';
+  return first.length > 120 ? `${first.slice(0, 117)}...` : first;
+}
+
+/** 骨架化 coreCode：去注释 + 截断 ≤ maxLines 行 */
+function _skeletonize(code, maxLines = 15) {
+  if (!code) return '';
+  const lines = code
+    .split('\n')
+    // 去掉纯注释行（// 或 /* 或 * (JSDoc续行) 或 # 开头）
+    .filter((l) => !/^\s*(\/\/|\/\*|\*\s|#\s)/.test(l))
+    // 去掉空行连续超过 1 行
+    .reduce((acc, line) => {
+      if (line.trim() === '' && acc.length > 0 && acc[acc.length - 1].trim() === '') {
+        return acc; // 跳过连续空行
+      }
+      acc.push(line);
+      return acc;
+    }, []);
+  if (lines.length <= maxLines) return lines.join('\n');
+  return `${lines.slice(0, maxLines).join('\n')}\n// ... (truncated)`;
+}
+
 export class KnowledgeCompressor {
   /**
-   * Channel A — 一行式规则
+   * Channel A — 一行式规则（含可选 language 前缀）
+   *
+   * 多语言项目中增加 [language] 前缀，帮助 Agent 判断规则适用性。
+   * scope='universal' 或无 language 的规则不加前缀。
+   *
    * @param {Array<Object>} entries - KnowledgeEntry 数组 (kind='rule')
    * @returns {Array<string>}
    */
@@ -18,10 +55,14 @@ export class KnowledgeCompressor {
     return entries
       .filter((e) => e.doClause) // 无 doClause → 跳过，不猜
       .map((e) => {
-        let line = e.doClause;
+        // 可选 language 前缀
+        const langPrefix =
+          e.language && e.scope !== 'universal' ? `[${e.language}] ` : '';
+        const doText = e.doClause.replace(/\.+$/, ''); // 去尾 .
+        let line = `${langPrefix}${doText}`;
         if (e.dontClause) {
-          // AI 可能返回 "Don't ..." / "Do not ..." 开头，去掉冗余前缀
-          const stripped = e.dontClause.replace(/^(Don't|Do not|Never)\s+/i, '');
+          // AI 可能返回 "Don't ..." / "Do not ..." / "Never ..." 开头，去掉冗余前缀后统一为 "Do NOT"
+          const stripped = e.dontClause.replace(/^(Don't|Do not|Never)\s+/i, '').replace(/\.+$/, '');
           line += `. Do NOT ${stripped}`;
         }
         return `- ${line}.`;
@@ -29,9 +70,9 @@ export class KnowledgeCompressor {
   }
 
   /**
-   * Channel B — When/Do/Don't + Template
+   * Channel B — When/Do/Don't/Why + Template（骨架化）
    * @param {Array<Object>} entries - KnowledgeEntry 数组 (kind='pattern')
-   * @returns {Array<{ trigger: string, when: string, do: string, dont: string, template: string }>}
+   * @returns {Array<{ trigger: string, when: string, do: string, dont: string, why: string, template: string }>}
    */
   compressToWhenDoDont(entries) {
     const seen = new Set();
@@ -48,18 +89,24 @@ export class KnowledgeCompressor {
           trigger = `${trigger}-${i}`;
         }
         seen.add(trigger);
+
+        // 提取 rationale 首句作 Why 行
+        const rationale = e.content?.rationale || '';
+        const why = _extractFirstSentence(rationale);
+
         return {
           trigger,
           when: e.whenClause,
           do: e.doClause,
           dont: e.dontClause || '',
-          template: e.coreCode || '',
+          why,
+          template: _skeletonize(e.coreCode),
         };
       });
   }
 
   /**
-   * 将 When/Do/Don't 结果格式化为 Markdown 字符串
+   * 将 When/Do/Don't/Why 结果格式化为 Markdown 字符串
    * @param {Array<Object>} compressed - compressToWhenDoDont 输出
    * @param {string} [language=''] - 代码围栏语言标识
    * @returns {string}
@@ -75,6 +122,9 @@ export class KnowledgeCompressor {
           const stripped = item.dont.replace(/^(Don't|Do not|Never)\s+/i, '');
           lines.push(`- **Don't**: ${stripped}`);
         }
+        if (item.why) {
+          lines.push(`- **Why**: ${item.why}`);
+        }
         if (item.template) {
           lines.push('');
           lines.push(`\`\`\`${lang}`);

package/lib/service/cursor/SkillsSyncer.js

@@ -208,15 +208,17 @@ export class SkillsSyncer {
     const lines = [`# ${this._capitalizeWords(dimensionLabel)} Recipes`, ''];
 
     if (recipes.length > 0) {
-      lines.push('| Title | Trigger | Summary |');
-      lines.push('|---|---|---|');
+      lines.push('| Title | Trigger | Kind | Lang | Summary |');
+      lines.push('|---|---|---|---|---|');
       for (const entry of recipes.slice(0, 20)) {
         const title = (entry.title || '').replace(/\|/g, '/');
         const trigger = entry.trigger || '-';
+        const kind = entry.kind || '-';
+        const lang = entry.language || '-';
         const summary = (entry.summaryCn || entry.description || '')
           .replace(/\|/g, '/')
           .slice(0, 80);
-        lines.push(`| ${title} | ${trigger} | ${summary} |`);
+        lines.push(`| ${title} | ${trigger} | ${kind} | ${lang} | ${summary} |`);
       }
     } else {
       lines.push('No recipes available yet. Run `asd bootstrap` to generate knowledge.');

package/lib/service/cursor/TopicClassifier.js

@@ -78,6 +78,11 @@ export class TopicClassifier {
 
   /**
    * 为主题构建 description — Agent 判断关联性的唯一依据
+   *
+   * v3: 动态丰富化 — 除硬编码 baseKeywords 外，还从 entries 的
+   * tags, whenClause, trigger 中提取高价值关键词，让 Cursor 的
+   * description 匹配更精准。
+   *
    * @param {string} topic
    * @param {Array<Object>} entries
    * @returns {string}
@@ -91,10 +96,21 @@ export class TopicClassifier {
           .filter(Boolean)
           .join(', ');
 
-    // 从 entries 提取额外关键词
+    // 从 entries 提取动态关键词（tags + whenClause + title/description）
     const entryKeywords = entries.flatMap((e) => this._extractKeywords(e)).filter(Boolean);
-    const unique = [...new Set(entryKeywords)].slice(0, 10);
-    const extra = unique.length > 0 ? `, ${unique.join(', ')}` : '';
+    // 从 tags 直接提取（tags 本身就是高质量关键词）
+    const tagKeywords = entries
+      .flatMap((e) => e.tags || [])
+      .map((t) => t.toLowerCase())
+      .filter((t) => t.length >= 2 && !STOP_WORDS.has(t));
+    // 从 whenClause 提取（包含触发场景信息）
+    const whenKeywords = entries
+      .flatMap((e) => (e.whenClause || '').match(/[a-zA-Z]{3,}/g) || [])
+      .map((w) => w.toLowerCase())
+      .filter((w) => !STOP_WORDS.has(w));
+
+    const allExtra = [...new Set([...tagKeywords, ...whenKeywords, ...entryKeywords])].slice(0, 15);
+    const extra = allExtra.length > 0 ? `, ${allExtra.join(', ')}` : '';
 
     return `${this._topicLabel(topic)} patterns for ${this.projectName} — ${baseKeywords}${extra}. Use when writing or reviewing ${this._topicLabel(topic).toLowerCase()}-related code.`;
   }

package/lib/service/guard/ExclusionManager.js

@@ -197,13 +197,37 @@ export class ExclusionManager {
   // ─── 私有方法 ─────────────────────────────────────────
 
   #matchGlob(filePath, pattern) {
-    // 简易 glob 匹配: ** 表示任意路径, * 表示同级任意文件名
+    // 简易 glob 匹配: ** 表示任意路径, * 表示同级任意文件名, ? 表示单个字符
+    // 1. 精确正则匹配 (支持 glob 通配符)
     const escaped = pattern
       .replace(/[.+^${}()|[\]\\]/g, '\\$&')
       .replace(/\*\*/g, '<<<GLOB>>>')
       .replace(/\*/g, '[^/]*')
+      .replace(/\?/g, '[^/]')
       .replace(/<<<GLOB>>>/g, '.*');
-    return new RegExp(`^${escaped}$`).test(filePath) || filePath.includes(pattern);
+    if (new RegExp(`^${escaped}$`).test(filePath)) {
+      return true;
+    }
+    // 1b. 不含 / 的通配符 pattern 按文件名匹配 (如 *.test.js 匹配任意路径下的文件名)
+    if (pattern.includes('*') && !pattern.includes('/')) {
+      const basename = filePath.split('/').pop() || '';
+      if (new RegExp(`^${escaped}$`).test(basename)) {
+        return true;
+      }
+    }
+    // 2. 路径段匹配 — pattern 不含通配符时，按完整路径段（/segment/）匹配
+    //    避免 "test" 匹配 "contest.js" 这类误报
+    if (!pattern.includes('*') && !pattern.includes('?')) {
+      const segments = filePath.split('/');
+      if (segments.includes(pattern)) {
+        return true;
+      }
+      // 后缀匹配: 支持 "src/foo.js" 匹配 "/project/src/foo.js"
+      if (pattern.includes('/') && filePath.endsWith(`/${pattern}`)) {
+        return true;
+      }
+    }
+    return false;
   }
 
   #load() {