autosnippet 2.16.0 → 2.18.0

package/lib/service/search/SearchEngine.js

@@ -6,6 +6,8 @@
  */
 
 import Logger from '../../infrastructure/logging/Logger.js';
+import { CoarseRanker } from './CoarseRanker.js';
+import { MultiSignalRanker } from './MultiSignalRanker.js';
 
 /**
  * BM25 参数
@@ -143,6 +145,8 @@ export class SearchEngine {
     this.aiProvider = options.aiProvider || null;
     this.vectorStore = options.vectorStore || null;
     this.scorer = new BM25Scorer();
+    this._coarseRanker = new CoarseRanker(options);
+    this._multiSignalRanker = new MultiSignalRanker(options);
     this._indexed = false;
     this._cache = new Map();
     this._cacheMaxAge = options.cacheMaxAge || 300_000; // 5min
@@ -161,7 +165,8 @@ export class SearchEngine {
       try {
         entries = this.db.prepare(
           `SELECT id, title, description, language, category, knowledgeType, kind,
-                  content, lifecycle, tags, trigger
+                  content, lifecycle, tags, trigger, difficulty, quality, stats,
+                  updatedAt, createdAt
            FROM knowledge_entries WHERE lifecycle != 'deprecated'`
         ).all();
         entries = entries.map(e => ({
@@ -178,10 +183,28 @@ export class SearchEngine {
         } catch { /* ignore parse error */ }
         // 包含 tags + trigger 提升召回率
         let tagText = '';
-        try { tagText = JSON.parse(r.tags || '[]').join(' '); } catch { /* ignore */ }
+        let parsedTags = [];
+        try { parsedTags = JSON.parse(r.tags || '[]'); tagText = parsedTags.join(' '); } catch { /* ignore */ }
+        // 解析 stats / quality JSON — 供排序信号使用
+        let usageCount = 0;
+        let authorityScore = 0;
+        try {
+          const stats = JSON.parse(r.stats || '{}');
+          usageCount = (stats.adoptions || 0) + (stats.applications || 0) + (stats.searchHits || 0);
+          authorityScore = stats.authority || 0;
+        } catch { /* ignore */ }
+        let qualityOverall = 0;
+        try { qualityOverall = JSON.parse(r.quality || '{}').overall || 0; } catch { /* ignore */ }
         const text = [r.title, r.description, r.trigger, r.language, r.category, r.knowledgeType, tagText, contentText]
           .filter(Boolean).join(' ');
-        this.scorer.addDocument(r.id, text, { type: 'knowledge', title: r.title, trigger: r.trigger || '', status: r.status, knowledgeType: r.knowledgeType, kind: r.kind || 'pattern', language: r.language || '', category: r.category || '' });
+        this.scorer.addDocument(r.id, text, {
+          type: 'knowledge', title: r.title, trigger: r.trigger || '', status: r.status,
+          knowledgeType: r.knowledgeType, kind: r.kind || 'pattern',
+          language: r.language || '', category: r.category || '',
+          updatedAt: r.updatedAt || null, createdAt: r.createdAt || null,
+          difficulty: r.difficulty || 'intermediate', tags: parsedTags,
+          usageCount, authorityScore, qualityScore: qualityOverall,
+        });
       }
 
       this._indexed = true;
@@ -194,38 +217,79 @@ export class SearchEngine {
     }
   }
 
+  /**
+   * 确保索引已构建（幂等），supply 给需要准确 stats 的调用方
+   */
+  ensureIndex() {
+    if (!this._indexed) {
+      this.buildIndex();
+    }
+  }
+
   /**
    * 统一搜索入口
    * @param {string} query - 搜索关键词
    * @param {object} options - {type, limit, mode, useAI}
    */
   async search(query, options = {}) {
-    const { type = 'all', limit = 20, mode = 'keyword' } = options;
+    const { type = 'all', limit = 20, mode = 'keyword', context } = options;
+    const shouldRank = options.rank ?? (mode !== 'keyword');
 
     if (!query || !query.trim()) {
       return { items: [], total: 0, query };
     }
 
-    // 检查缓存
-    const cacheKey = `${query}:${type}:${limit}:${mode}:${options.groupByKind ? 'g' : ''}`;
-    const cached = this._getCache(cacheKey);
-    if (cached) return cached;
+    // 带 sessionHistory 的上下文搜索不缓存（个性化结果）
+    const hasSessionContext = context?.sessionHistory?.length > 0;
+    const cacheKey = hasSessionContext
+      ? null
+      : `${query}:${type}:${limit}:${mode}:${shouldRank ? 'r' : ''}:${options.groupByKind ? 'g' : ''}`;
+    if (cacheKey) {
+      const cached = this._getCache(cacheKey);
+      if (cached) return cached;
+    }
 
     // 确保索引已构建
-    if (!this._indexed) {
-      this.buildIndex();
-    }
+    this.ensureIndex();
 
+    // 排序阶段需要更多候选，过采样 3x
+    const recallLimit = shouldRank ? limit * 3 : limit;
     let results;
-    let actualMode = mode;  // 跟踪实际使用的搜索模式（semantic 可能降级为 bm25）
+    let actualMode = mode;
 
     switch (mode) {
+      case 'auto': {
+        // 同时做 BM25 + semantic，融合去重取最优分数
+        const [bm25Items, semResult] = await Promise.all([
+          Promise.resolve(this._bm25Search(query, type, recallLimit)),
+          this._semanticSearch(query, type, recallLimit).catch(() => ({ items: [], actualMode: 'bm25' })),
+        ]);
+        const semItems = semResult.items || [];
+        const merged = new Map();
+        for (const it of bm25Items) {
+          merged.set(it.id, { ...it, _bm25: it.score || 0, _sem: 0 });
+        }
+        for (const it of semItems) {
+          const existing = merged.get(it.id);
+          if (existing) {
+            existing._sem = it.score || 0;
+            existing.score = Math.max(existing._bm25, existing._sem);
+          } else {
+            merged.set(it.id, { ...it, _bm25: 0, _sem: it.score || 0 });
+          }
+        }
+        results = [...merged.values()].sort((a, b) => b.score - a.score);
+        for (const it of results) { delete it._bm25; delete it._sem; }
+        const semActuallyUsed = semResult.actualMode === 'semantic';
+        actualMode = semActuallyUsed ? 'auto(bm25+semantic)' : 'auto(bm25-only)';
+        break;
+      }
       case 'ranking':
       case 'bm25':
-        results = this._bm25Search(query, type, limit);
+        results = this._bm25Search(query, type, recallLimit);
         break;
       case 'semantic': {
-        const semResult = await this._semanticSearch(query, type, limit);
+        const semResult = await this._semanticSearch(query, type, recallLimit);
         results = semResult.items || semResult;
         actualMode = semResult.actualMode || 'semantic';
         break;
@@ -236,27 +300,110 @@ export class SearchEngine {
         break;
     }
 
+    // ── Ranking Pipeline (CoarseRanker → MultiSignalRanker → ContextBoost) ──
+    if (shouldRank && results.length > 0) {
+      results = this._applyRanking(results, query, context);
+    }
+    results = results.slice(0, limit);
+
     const response = {
       items: results,
       total: results.length,
       query,
       mode: actualMode,
       type,
+      ranked: shouldRank && results.length > 0,
     };
 
-    // 按 kind 分组输出
     if (options.groupByKind) {
-      response.byKind = {
-        rule: results.filter(r => r.kind === 'rule'),
-        pattern: results.filter(r => r.kind === 'pattern'),
-        fact: results.filter(r => r.kind === 'fact'),
-      };
+      response.byKind = { rule: [], pattern: [], fact: [] };
+      for (const r of results) {
+        const kind = r.kind || 'pattern';
+        (response.byKind[kind] || response.byKind.pattern).push(r);
+      }
     }
 
-    this._setCache(cacheKey, response);
+    if (cacheKey) this._setCache(cacheKey, response);
     return response;
   }
 
+  // ── Ranking Pipeline ────────────────────────────────────────────
+
+  /**
+   * 内置排序管线: 规范化 → CoarseRanker (E-E-A-T 5维) → MultiSignalRanker (6信号) → 上下文加成
+   */
+  _applyRanking(items, query, context = {}) {
+    const normalized = this._normalizeForRanking(items);
+    let ranked = this._coarseRanker.rank(normalized);
+    ranked = this._multiSignalRanker.rank(ranked, {
+      ...context, query,
+      scenario: context?.intent || 'search',
+    });
+    if (context?.sessionHistory?.length > 0) {
+      ranked = this._contextBoost(ranked, context);
+    }
+    return ranked.map(r => ({
+      ...r,
+      recallScore: r.bm25Score || 0,
+      score: r.contextScore || r.rankerScore || r.coarseScore || r.bm25Score || 0,
+    }));
+  }
+
+  /**
+   * 将召回结果转换为 Ranker 所需格式（解析 content JSON、映射信号字段）
+   * 保留原始 content 供下游消费者使用
+   */
+  _normalizeForRanking(items) {
+    return items.map(item => {
+      let codeText = '';
+      if (item.content) {
+        try {
+          const parsed = typeof item.content === 'string' ? JSON.parse(item.content) : item.content;
+          codeText = parsed.pattern || parsed.code || '';
+        } catch { /* ignore */ }
+      }
+      let tags = item.tags || [];
+      if (typeof tags === 'string') {
+        try { tags = JSON.parse(tags); } catch { tags = []; }
+      }
+      return {
+        ...item,
+        code: codeText || item.code || '',
+        bm25Score: item.score || 0,
+        qualityScore: item.qualityScore || (item.status === 'active' ? 70 : 40),
+        usageCount: item.usageCount || 0,
+        authorityScore: item.authorityScore || 0,
+        tags,
+        difficulty: item.difficulty || 'intermediate',
+      };
+    });
+  }
+
+  /**
+   * 上下文感知加成 — 会话关键词重叠 +20%、语言匹配 +10%
+   */
+  _contextBoost(items, context) {
+    const { sessionHistory = [], language } = context || {};
+    if (!sessionHistory.length) return items;
+    const sessionKeywords = new Set();
+    for (const turn of sessionHistory) {
+      const tokens = tokenize(turn.content || turn.rawInput || '');
+      for (const t of tokens) sessionKeywords.add(t);
+    }
+    return items.map(item => {
+      let boost = 0;
+      const textTokens = tokenize(
+        [item.title, item.trigger, item.content].filter(Boolean).join(' ')
+      );
+      const overlap = textTokens.filter(t => sessionKeywords.has(t)).length;
+      if (overlap > 0) boost += 0.2 * Math.min(overlap / 5, 1);
+      if (language && item.language === language) boost += 0.1;
+      const baseScore = item.rankerScore || item.coarseScore || item.score || 0;
+      const contextScore = baseScore * (1 + boost);
+      return { ...item, contextScore, contextBoost: boost };
+    }).sort((a, b) => b.contextScore - a.contextScore);
+  }
+
   /**
    * 关键词搜索 - 直接 SQL LIKE
    * 返回包含 kind 字段的完整结果，使用 ESCAPE 防止通配符注入
@@ -318,6 +465,14 @@ export class SearchEngine {
       language: r.meta.language || '',
       category: r.meta.category || '',
       score: Math.round(r.score * 1000) / 1000,
+      // 排序信号字段（供 RetrievalFunnel / CoarseRanker / MultiSignalRanker 使用）
+      updatedAt: r.meta.updatedAt || null,
+      createdAt: r.meta.createdAt || null,
+      difficulty: r.meta.difficulty || 'intermediate',
+      tags: r.meta.tags || [],
+      usageCount: r.meta.usageCount || 0,
+      authorityScore: r.meta.authorityScore || 0,
+      qualityScore: r.meta.qualityScore || 0,
     }));
 
     // 为每个结果补充 content（NativeUI 预览需要）— 批量 IN 查询替代 N+1
@@ -343,10 +498,19 @@ export class SearchEngine {
         return { items: this._bm25Search(query, type, limit), actualMode: 'bm25' };
       }
 
-      // 尝试通过 vectorStore 做的向量相似度搜索
+      // 尝试通过 vectorStore 做向量搜索（优先混合搜索: 向量70% + 关键词30%）
       if (this.vectorStore) {
         try {
-          const vectorResults = await this.vectorStore.query(queryEmbedding, limit * 2);
+          let vectorResults;
+          if (typeof this.vectorStore.hybridSearch === 'function') {
+            const hybrid = await this.vectorStore.hybridSearch(queryEmbedding, query, { topK: limit * 2 });
+            vectorResults = hybrid.map(r => ({
+              id: r.item.id, similarity: r.score, score: r.score,
+              content: r.item.content, metadata: r.item.metadata || {},
+            }));
+          } else {
+            vectorResults = await this.vectorStore.query(queryEmbedding, limit * 2);
+          }
           if (vectorResults && vectorResults.length > 0) {
             let results = vectorResults.map(vr => ({
               id: vr.id,
@@ -393,7 +557,9 @@ export class SearchEngine {
       let rows = [];
       try {
         rows = this.db.prepare(
-          `SELECT id, content, description, trigger, headers, moduleName FROM knowledge_entries WHERE id IN (${placeholders})`
+          `SELECT id, content, description, trigger, headers, moduleName,
+                  tags, language, category, updatedAt, createdAt, quality, stats, difficulty
+           FROM knowledge_entries WHERE id IN (${placeholders})`
         ).all(...ids);
       } catch { /* table may not exist */ }
       const rowMap = new Map(rows.map(r => [r.id, r]));
@@ -405,6 +571,28 @@ export class SearchEngine {
           item.trigger = item.trigger || row.trigger || '';
           if (row.headers) item.headers = row.headers;
           if (row.moduleName) item.moduleName = row.moduleName;
+          // 排序信号补充 — 确保 Funnel/Ranker 有真实数据
+          if (!item.language && row.language) item.language = row.language;
+          if (!item.category && row.category) item.category = row.category;
+          if (!item.updatedAt && row.updatedAt) item.updatedAt = row.updatedAt;
+          if (!item.createdAt && row.createdAt) item.createdAt = row.createdAt;
+          if (!item.difficulty && row.difficulty) item.difficulty = row.difficulty;
+          // 解析 tags
+          if (!item.tags || (Array.isArray(item.tags) && item.tags.length === 0)) {
+            try { item.tags = JSON.parse(row.tags || '[]'); } catch { /* ignore */ }
+          }
+          // 解析 quality JSON → qualityScore
+          if (!item.qualityScore) {
+            try { item.qualityScore = JSON.parse(row.quality || '{}').overall || 0; } catch { /* ignore */ }
+          }
+          // 解析 stats JSON → usageCount + authorityScore
+          if (!item.usageCount) {
+            try {
+              const stats = JSON.parse(row.stats || '{}');
+              item.usageCount = (stats.adoptions || 0) + (stats.applications || 0) + (stats.searchHits || 0);
+              if (!item.authorityScore) item.authorityScore = stats.authority || 0;
+            } catch { /* ignore */ }
+          }
         }
       }
     } catch { /* DB may not be available */ }
@@ -419,7 +607,7 @@ export class SearchEngine {
   }
 
   /**
-   * 获取索引统计
+   * 获取索引统计（如果尚未构建索引，自动触发构建）
    */
   getStats() {
     return {

package/package.json

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

package/resources/native-ui/combined-window.swift

@@ -333,13 +333,13 @@ class CombinedSearchWindowController: NSObject, NSTableViewDataSource, NSTableVi
         let cellView = NSTableCellView()
         cellView.wantsLayer = true
         
-        // 标题 - 支持两行显示
+        // 标题 - 自动折行，最多两行，右侧留出足够边距
         let textField = NSTextField(labelWithString: item.title)
         textField.font = NSFont.systemFont(ofSize: 14, weight: .medium)
         textField.textColor = .labelColor
-        textField.lineBreakMode = .byWordWrapping  // 改为自动换行
-        textField.maximumNumberOfLines = 2  // 最多显示两行
-        textField.frame = NSRect(x: 12, y: 24, width: tableView.bounds.width - 24, height: 36)  // 增加高度到36，调整y位置
+        textField.lineBreakMode = .byWordWrapping
+        textField.maximumNumberOfLines = 2  // 必须两行保证显示全
+        textField.frame = NSRect(x: 12, y: 24, width: tableView.bounds.width - 56, height: 36)
         cellView.addSubview(textField)
         
         // 说明
@@ -356,7 +356,7 @@ class CombinedSearchWindowController: NSObject, NSTableViewDataSource, NSTableVi
             subtitleField.font = NSFont.systemFont(ofSize: 11, weight: .regular)
             subtitleField.textColor = .secondaryLabelColor
             subtitleField.lineBreakMode = .byTruncatingTail
-            subtitleField.frame = NSRect(x: 12, y: 8, width: tableView.bounds.width - 24, height: 16)  // 调整y位置为8
+            subtitleField.frame = NSRect(x: 12, y: 8, width: tableView.bounds.width - 56, height: 16)
             cellView.addSubview(subtitleField)
         }