autosnippet 3.4.0 → 3.4.2

package/dist/lib/service/search/SearchEngine.js

@@ -110,6 +110,7 @@ export class SearchEngine {
     async search(query, options = {}) {
         const { type = 'all', limit = 20, mode = 'keyword', context } = options;
         const shouldRank = options.rank ?? mode !== 'keyword';
+        const tSearchStart = performance.now();
         if (!query || !query.trim()) {
             return { items: [], total: 0, query };
         }
@@ -132,60 +133,62 @@ export class SearchEngine {
         let actualMode = mode;
         switch (mode) {
             case 'auto': {
-                // 缓存 FieldWeighted 结果, 避免 RRF 降级时重复计算
-                let cachedScorerItems = null;
-                const getScorerResults = () => {
-                    if (!cachedScorerItems) {
-                        cachedScorerItems = this._scorerSearch(query, type, recallLimit);
-                    }
-                    return cachedScorerItems;
-                };
-                // 优先使用 VectorService 的 hybridSearch (统一 RRF 融合)
-                if (this.vectorService) {
-                    try {
-                        const sparseItems = getScorerResults();
-                        const rrfResults = await this.vectorService.hybridSearch(query, {
-                            topK: recallLimit,
-                            alpha: this._fusionSemanticWeight,
-                            sparseSearchFn: () => sparseItems,
+                // ── Weighted-First + Confidence Gate ──
+                // 先跑 weighted（~40ms），评估是否需要 embed（2-22s）
+                const weightedItems = this._scorerSearch(query, type, recallLimit);
+                const confidence = this.#computeWeightedConfidence(query, weightedItems, limit);
+                if (confidence >= 60 || !this.vectorService) {
+                    // 高 confidence: weighted 已足够，跳过 embed
+                    results = weightedItems;
+                    actualMode = `auto(weighted-only,conf=${confidence})`;
+                    this.logger.info(`[QueryRouter] skip-semantic: conf=${confidence} topScore=${weightedItems[0]?.score ?? 0} query="${query}"`);
+                    break;
+                }
+                // 低 confidence: 投入 embed，RRF 融合
+                // 自适应 alpha：confidence 越低 → semantic 权重越高
+                // conf=0 → alpha=0.75, conf=30 → alpha=0.575, conf=55 → alpha=0.42
+                const adaptiveAlpha = this._fusionSemanticWeight + (0.75 - this._fusionSemanticWeight) * (1 - confidence / 60);
+                this.logger.info(`[QueryRouter] invoke-semantic: conf=${confidence} alpha=${adaptiveAlpha.toFixed(2)} topScore=${weightedItems[0]?.score ?? 0} query="${query}"`);
+                try {
+                    const rrfResults = await this.vectorService.hybridSearch(query, {
+                        topK: recallLimit,
+                        alpha: adaptiveAlpha,
+                        sparseSearchFn: () => weightedItems,
+                    });
+                    if (rrfResults.length > 0) {
+                        results = rrfResults.map((r) => {
+                            const base = r.data?.item ||
+                                r.data ||
+                                {};
+                            const baseMeta = (base.metadata || {});
+                            return {
+                                id: r.id,
+                                title: (base.title ||
+                                    baseMeta.title ||
+                                    r.id),
+                                type: (base.type || 'recipe'),
+                                kind: (base.kind ||
+                                    baseMeta.kind ||
+                                    'pattern'),
+                                status: (base.status ||
+                                    baseMeta.status ||
+                                    'active'),
+                                score: Math.round(r.score * 1000) / 1000,
+                                content: base.content,
+                                description: base.description,
+                            };
                         });
-                        if (rrfResults.length > 0) {
-                            results = rrfResults.map((r) => {
-                                const base = r.data?.item ||
-                                    r.data ||
-                                    {};
-                                const baseMeta = (base.metadata || {});
-                                return {
-                                    id: r.id,
-                                    title: (base.title ||
-                                        baseMeta.title ||
-                                        r.id),
-                                    type: (base.type || 'recipe'),
-                                    kind: (base.kind ||
-                                        baseMeta.kind ||
-                                        'pattern'),
-                                    status: (base.status ||
-                                        baseMeta.status ||
-                                        'active'),
-                                    score: Math.round(r.score * 1000) / 1000,
-                                    content: base.content,
-                                    description: base.description,
-                                };
-                            });
-                            this._supplementDetails(results);
-                            actualMode = 'auto(rrf)';
-                            break;
-                        }
-                    }
-                    catch {
-                        // VectorService RRF 失败, 降级到 min-max 融合
+                        this._supplementDetails(results);
+                        actualMode = `auto(rrf,conf=${confidence},α=${adaptiveAlpha.toFixed(2)})`;
+                        break;
                     }
                 }
-                // 降级: VectorService 不可用或 RRF 零结果 → 纯 FieldWeighted
-                // 旧版在此做 BM25+semantic min-max 融合，但当 VectorService 不可用时
-                // semantic 通常也会失败，最终退化为纯 FieldWeighted。简化为直接走 scorer。
-                results = getScorerResults();
-                actualMode = 'auto(weighted-only)';
+                catch {
+                    // VectorService RRF 失败, 降级
+                }
+                // 降级: embed 失败 → 返回已有的 weighted 结果
+                results = weightedItems;
+                actualMode = `auto(weighted-fallback,conf=${confidence})`;
                 break;
             }
             case 'weighted':
@@ -215,6 +218,9 @@ export class SearchEngine {
             type,
             ranked: shouldRank && results.length > 0,
         };
+        // ── 搜索计时日志 ──
+        const tSearchEnd = performance.now();
+        this.logger.info(`Search completed: mode=${actualMode} total=${results.length} time=${Math.round(tSearchEnd - tSearchStart)}ms ranked=${response.ranked} query="${query}"`);
         if (options.groupByKind) {
             response.byKind = { rule: [], pattern: [], fact: [] };
             for (const r of results) {
@@ -448,15 +454,20 @@ export class SearchEngine {
                     let results = vectorResults.map((vr) => {
                         const item = vr.item;
                         const metadata = (item.metadata || {});
+                        const rawId = item.id || '';
+                        // 从 vector ID 提取 DB entryId: "entry_<uuid>" → "<uuid>"
+                        const entryId = metadata.entryId || rawId.replace(/^entry_/, '');
                         return {
-                            id: item.id || metadata.entryId || '',
-                            title: metadata.title || item.id || '',
+                            id: entryId,
+                            title: metadata.title || entryId,
                             type: 'recipe',
                             kind: metadata.kind || 'pattern',
                             status: metadata.status || 'active',
                             score: Math.round(vr.score * 1000) / 1000,
                         };
                     });
+                    // 按 entryId 去重 — 同一 Recipe 的多个 chunk 只保留最高分
+                    results = this.#deduplicateByEntryId(results);
                     if (type !== 'all') {
                         results = results.filter((r) => {
                             if (type === 'rule') {
@@ -505,14 +516,20 @@ export class SearchEngine {
                         vectorResults = await this.vectorStore.query(queryEmbedding, limit * 2);
                     }
                     if (vectorResults && vectorResults.length > 0) {
-                        let results = vectorResults.map((vr) => ({
-                            id: vr.id,
-                            title: vr.metadata?.title || vr.id,
-                            type: 'recipe',
-                            kind: vr.metadata?.kind || 'pattern',
-                            status: vr.metadata?.status || 'active',
-                            score: Math.round((vr.similarity || vr.score || 0) * 1000) / 1000,
-                        }));
+                        let results = vectorResults.map((vr) => {
+                            const rawId = vr.id || '';
+                            const entryId = vr.metadata?.entryId || rawId.replace(/^entry_/, '');
+                            return {
+                                id: entryId,
+                                title: vr.metadata?.title || entryId,
+                                type: 'recipe',
+                                kind: vr.metadata?.kind || 'pattern',
+                                status: vr.metadata?.status || 'active',
+                                score: Math.round((vr.similarity || vr.score || 0) * 1000) / 1000,
+                            };
+                        });
+                        // 按 entryId 去重
+                        results = this.#deduplicateByEntryId(results);
                         if (type !== 'all') {
                             results = results.filter((r) => {
                                 if (type === 'rule') {
@@ -542,6 +559,93 @@ export class SearchEngine {
             return { items: this._scorerSearch(query, type, limit), actualMode: 'weighted' };
         }
     }
+    /**
+     * 按 entryId 去重 — 同一 Recipe 的多个 chunk 只保留最高分的
+     * 解决向量搜索返回同一条目的多个 chunk 浪费结果位的问题
+     */
+    #deduplicateByEntryId(items) {
+        const seen = new Map();
+        for (const item of items) {
+            const existing = seen.get(item.id);
+            if (!existing || (item.score ?? 0) > (existing.score ?? 0)) {
+                seen.set(item.id, item);
+            }
+        }
+        return [...seen.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    }
+    /**
+     * 评估 weighted 搜索结果的 confidence，决定是否需要语义搜索
+     * 返回 0-100 的分数，>= 60 跳过语义
+     */
+    #computeWeightedConfidence(query, items, requestedLimit) {
+        let score = 0;
+        // ── 结果质量信号 ──
+        // FieldWeightedScorer 分数范围约 0-20，归一化后判断
+        const topScore = items[0]?.score ?? 0;
+        const secondScore = items[1]?.score ?? 0;
+        // top1 与 top2 分差大 → 明确命中
+        if (items.length >= 2 && topScore > 0) {
+            const relativeGap = (topScore - secondScore) / topScore;
+            if (relativeGap > 0.3) {
+                score += 25;
+            }
+            else if (relativeGap > 0.15) {
+                score += 15;
+            }
+        }
+        // title/trigger 匹配（子串级别）
+        const lq = query.toLowerCase();
+        const matchLevel = items.slice(0, 3).reduce((best, it) => {
+            const t = (it.title || '').toLowerCase();
+            const tr = (it.trigger || '').toLowerCase();
+            if (t === lq || tr === lq || tr === `@${lq}`) {
+                return Math.max(best, 3); // 完全匹配
+            }
+            if (t.includes(lq) || tr.includes(lq)) {
+                return Math.max(best, 2); // 子串匹配
+            }
+            if (lq.includes(t) && t.length > 3) {
+                return Math.max(best, 1); // 反向包含
+            }
+            return best;
+        }, 0);
+        if (matchLevel === 3) {
+            score += 50;
+        }
+        else if (matchLevel === 2) {
+            score += 35;
+        }
+        else if (matchLevel === 1) {
+            score += 15;
+        }
+        // 代码术语检测（CamelCase、snake_case、@trigger）
+        if (/^[A-Z][a-zA-Z0-9]+$/.test(query) ||
+            /^[a-z]+(_[a-z]+)+$/.test(query) ||
+            query.startsWith('@')) {
+            score += 25;
+        }
+        // 候选充足
+        if (items.length >= requestedLimit) {
+            score += 10;
+        }
+        // ── 查询特征信号（降低 confidence → 倾向调用语义）──
+        // 中文自然语言疑问句
+        if (/[如怎什为何哪]么?|是否|有没有|都有哪些|应该|需要/.test(query)) {
+            score -= 40;
+        }
+        // 英文自然语言问句
+        if (/^(how|what|why|when|where|which|can|does|is|should)\b/i.test(query)) {
+            score -= 40;
+        }
+        // 较长查询（可能是描述性语句）
+        if (query.length > 20) {
+            score -= 20;
+        }
+        else if (query.length > 10) {
+            score -= 10;
+        }
+        return Math.max(0, Math.min(100, score));
+    }
     /**
      * 补充详细字段（content / description / trigger / delivery 字段）— 批量 IN 查询
      * 用于向量搜索结果与 FieldWeighted 结果的一致性

package/dist/lib/service/task/PrimeSearchPipeline.js

@@ -108,15 +108,30 @@ export class PrimeSearchPipeline {
         const autoPromises = autoQueries.map((q) => this.#search
             .search(q, { mode: 'auto', limit: 8, rank: false, context })
             .catch(() => ({ items: [] })));
+        // Semantic-mode search for primary query — ensures semantic is always
+        // part of RRF fusion even when auto mode skips it (confidence ≥ 60)
+        const semanticPromise = autoQueries[0]
+            ? this.#search
+                .search(autoQueries[0], { mode: 'semantic', limit: 6, rank: false })
+                .catch(() => ({ items: [] }))
+            : Promise.resolve({ items: [] });
         // Keyword-mode searches (raw FWS scores — for cross-language synonym matching)
         const kwPromises = keywordQueries.map((q) => this.#search
             .search(q, { mode: 'keyword', limit: 8, rank: false })
             .catch(() => ({ items: [] })));
-        const [autoResponses, kwResponses] = await Promise.all([
+        const [autoResponses, kwResponses, semanticResponse] = await Promise.all([
             Promise.all(autoPromises),
             Promise.all(kwPromises),
+            semanticPromise,
         ]);
-        const allResponses = [...autoResponses, ...kwResponses];
+        // Merge: auto + semantic + keyword
+        const semanticItems = (semanticResponse.items ||
+            []);
+        const allResponses = [
+            ...autoResponses,
+            ...(semanticItems.length > 0 ? [semanticResponse] : []),
+            ...kwResponses,
+        ];
         // Single-query shortcut: preserve original scores from search engine.
         // RRF is pointless with one response — it just converts rank to score,
         // discarding the magnitude information from BM25/CoarseRanker.

package/dist/lib/service/vector/VectorService.js

@@ -201,13 +201,18 @@ export class VectorService {
         }
         const { topK = 10, filter = null, minScore = 0 } = opts;
         try {
+            const t0 = performance.now();
             const embedResult = await this.#embedProvider.embed(query);
+            const tEmbed = performance.now();
             const queryVector = Array.isArray(embedResult[0]) ? embedResult[0] : embedResult;
-            return this.#vectorStore.searchVector(queryVector, {
+            const results = await this.#vectorStore.searchVector(queryVector, {
                 topK,
                 filter,
                 minScore,
             });
+            const tHnsw = performance.now();
+            this.#logger.info(`[VectorService] search: embed=${Math.round(tEmbed - t0)}ms hnsw=${Math.round(tHnsw - tEmbed)}ms total=${Math.round(tHnsw - t0)}ms results=${results.length}`);
+            return results;
         }
         catch (err) {
             this.#logger.warn('[VectorService] search failed', {
@@ -240,6 +245,7 @@ export class VectorService {
         // Embed query — circuit breaker skips embed after repeated failures
         let queryVector = null;
         const circuitOpen = Date.now() < this.#embedCircuitOpenUntil;
+        const tEmbedStart = performance.now();
         if (circuitOpen) {
             this.#logger.debug('[VectorService] embed circuit open, skipping embed');
         }
@@ -267,12 +273,15 @@ export class VectorService {
                 }
             }
         }
+        const tEmbedEnd = performance.now();
         try {
             const fused = await this.#hybridRetriever.search(query, queryVector, {
                 topK,
                 alpha,
                 sparseSearchFn: sparseSearchFn ?? undefined,
             });
+            const tFuseEnd = performance.now();
+            this.#logger.info(`[VectorService] hybridSearch: embed=${Math.round(tEmbedEnd - tEmbedStart)}ms fuse=${Math.round(tFuseEnd - tEmbedEnd)}ms total=${Math.round(tFuseEnd - tEmbedStart)}ms hasVector=${!!queryVector} results=${fused.length} alpha=${alpha}`);
             return fused.map((r) => ({
                 id: r.id || '',
                 score: r.score || 0,

package/dist/lib/shared/LanguageService.d.ts

@@ -161,5 +161,17 @@ export declare class LanguageService {
         discovererIds?: string[];
         maxDepth?: number;
     }): unknown[];
+    /**
+     * 判定文件路径是否为测试文件
+     *
+     * 两层判定：
+     *   1. 语言特定的文件名模式（_test.go, .test.ts, test_*.py 等）
+     *   2. 通用测试目录模式（test/, tests/, __tests__/, spec/ 等）
+     *
+     * @param filePath 文件路径（相对或绝对均可）
+     * @param [language] 已知语言 ID，省略时从扩展名推断
+     * @returns 是否为测试文件
+     */
+    static isTestFile(filePath: string, language?: string): boolean;
 }
 export default LanguageService;

package/dist/lib/shared/LanguageService.js

@@ -275,6 +275,10 @@ const SCAN_SKIP_DIRS = Object.freeze(new Set([
     '.cargo',
 ]));
 // ═══════════════════════════════════════════════════════════
+// 7.5) 通用测试目录模式（路径中包含典型测试目录名）
+// ═══════════════════════════════════════════════════════════
+const TEST_DIR_PATTERN = /(?:^|[/\\])(?:tests?|__tests__|spec|__mocks__|testdata|test_driver|integration_test|e2e)[/\\]/;
+// ═══════════════════════════════════════════════════════════
 // Lazy caches
 // ═══════════════════════════════════════════════════════════
 let _sourceExtRegex = null;
@@ -567,6 +571,14 @@ export class LanguageService {
                         langSet.add(lang);
                     }
                 }
+                // 启发式: node 与其他生态共存时，JS/TS 通常只是构建工具，去掉
+                if (nonGeneric.length > 1 && nonGeneric.includes('node')) {
+                    const hasOther = nonGeneric.some((e) => e !== 'node');
+                    if (hasOther) {
+                        langSet.delete('javascript');
+                        langSet.delete('typescript');
+                    }
+                }
                 if (langSet.size > 0) {
                     return [...langSet];
                 }
@@ -647,5 +659,78 @@ export class LanguageService {
         }
         return [...langSet];
     }
+    // ═══════════════════════════════════════════════════════════
+    // 9) 测试文件判定 — 统一入口
+    // ═══════════════════════════════════════════════════════════
+    /**
+     * 判定文件路径是否为测试文件
+     *
+     * 两层判定：
+     *   1. 语言特定的文件名模式（_test.go, .test.ts, test_*.py 等）
+     *   2. 通用测试目录模式（test/, tests/, __tests__/, spec/ 等）
+     *
+     * @param filePath 文件路径（相对或绝对均可）
+     * @param [language] 已知语言 ID，省略时从扩展名推断
+     * @returns 是否为测试文件
+     */
+    static isTestFile(filePath, language) {
+        if (!filePath) {
+            return false;
+        }
+        const name = filePath.split(/[/\\]/).pop() || '';
+        const lang = language || LanguageService.inferLang(name);
+        // ── 1. 语言特定的文件名模式 ──
+        switch (lang) {
+            case 'go':
+                if (name.endsWith('_test.go')) {
+                    return true;
+                }
+                break;
+            case 'swift':
+                if (name.endsWith('Tests.swift') || name.endsWith('Test.swift')) {
+                    return true;
+                }
+                break;
+            case 'rust':
+                if (name.endsWith('_test.rs') || name.startsWith('test_')) {
+                    return true;
+                }
+                break;
+            case 'javascript':
+            case 'typescript':
+                if (/\.(test|spec)\.(js|ts|jsx|tsx|mjs|mts)$/.test(name)) {
+                    return true;
+                }
+                break;
+            case 'python':
+                if (name.startsWith('test_') || name.endsWith('_test.py')) {
+                    return true;
+                }
+                break;
+            case 'java':
+            case 'kotlin':
+                if (name.endsWith('Test.java') ||
+                    name.endsWith('Test.kt') ||
+                    name.endsWith('Tests.java') ||
+                    name.endsWith('Tests.kt')) {
+                    return true;
+                }
+                break;
+            case 'ruby':
+                if (name.endsWith('_spec.rb') || name.endsWith('_test.rb') || name.startsWith('test_')) {
+                    return true;
+                }
+                break;
+            case 'dart':
+                if (name.endsWith('_test.dart')) {
+                    return true;
+                }
+                break;
+            default:
+                break;
+        }
+        // ── 2. 通用测试目录模式 ──
+        return TEST_DIR_PATTERN.test(filePath);
+    }
 }
 export default LanguageService;

package/dist/lib/shared/schemas/http-requests.d.ts

@@ -303,6 +303,10 @@ export declare const AiEnvConfigBody: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
     apiKey: z.ZodOptional<z.ZodString>;
     proxy: z.ZodOptional<z.ZodString>;
+    embedProvider: z.ZodOptional<z.ZodString>;
+    embedModel: z.ZodOptional<z.ZodString>;
+    embedBaseUrl: z.ZodOptional<z.ZodString>;
+    embedApiKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const ExtractPathBody: z.ZodObject<{
     relativePath: z.ZodString;

package/dist/lib/shared/schemas/http-requests.js

@@ -303,6 +303,10 @@ export const AiEnvConfigBody = z.object({
     model: z.string().optional(),
     apiKey: z.string().optional(),
     proxy: z.string().optional(),
+    embedProvider: z.string().optional(),
+    embedModel: z.string().optional(),
+    embedBaseUrl: z.string().optional(),
+    embedApiKey: z.string().optional(),
 });
 // ═══ Extract Routes ══════════════════════════════
 export const ExtractPathBody = z.object({

package/dist/lib/types/project-snapshot.d.ts

@@ -63,6 +63,7 @@ export interface AstSummary {
 }
 export interface AstClassInfo {
     name: string;
+    kind?: string;
     superclass?: string;
     methodCount?: number;
     methods?: unknown[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autosnippet",
-  "version": "3.4.0",
+  "version": "3.4.2",
   "description": "Extract code patterns into a knowledge base for AI coding assistants",
   "type": "module",
   "main": "dist/lib/bootstrap.js",