autosnippet 3.3.2 → 3.3.4

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

@@ -6,6 +6,7 @@
  *
  * @module service/task/IntentExtractor
  */
+import { tokenize } from '#service/search/tokenizer.js';
 // ── Universal Patterns (language-agnostic) ──────────
 const UNIVERSAL_PATTERNS = [
     /\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b/g, // CamelCase
@@ -29,6 +30,81 @@ const LANG_MAP = {
     java: 'java',
     kt: 'kotlin',
 };
+// ── Cross-Language Synonym Groups ───────────────────
+// Each group contains EN morphological variants + CN equivalents.
+// Used to expand queries so English terms match Chinese recipe fields (and vice versa).
+const SYNONYM_GROUPS = [
+    // Design patterns & DI
+    ['inject', 'injection', '注入'],
+    ['construct', 'constructor', '构造器', '构造函数'],
+    ['depend', 'dependency', 'dependencies', '依赖'],
+    ['protocol', '协议'],
+    ['interface', '接口'],
+    ['pattern', '模式'],
+    ['factory', '工厂'],
+    ['singleton', '单例'],
+    ['delegate', '代理', '委托'],
+    ['observe', 'observer', '观察者'],
+    ['subscribe', 'subscription', '订阅'],
+    ['repository', 'repo', '仓库'],
+    // Architecture
+    ['module', '模块'],
+    ['architect', 'architecture', '架构'],
+    ['route', 'router', 'routing', '路由'],
+    ['middleware', '中间件'],
+    ['component', '组件'],
+    ['lifecycle', '生命周期'],
+    ['layer', '分层', '层'],
+    // Language features
+    ['generic', 'generics', '泛型'],
+    ['closure', '闭包'],
+    ['callback', '回调'],
+    ['extend', 'extension', '扩展'],
+    ['inherit', 'inheritance', '继承'],
+    ['abstract', 'abstraction', '抽象'],
+    ['encapsulate', 'encapsulation', '封装'],
+    ['polymorph', 'polymorphism', '多态'],
+    ['implement', 'implementation', '实现'],
+    // Concurrency
+    ['async', 'asynchronous', '异步'],
+    ['sync', 'synchronous', '同步'],
+    ['thread', 'threading', '线程'],
+    ['concur', 'concurrency', '并发'],
+    // Memory management
+    ['memory', '内存'],
+    ['leak', 'leakage', '泄漏'],
+    ['weak', '弱引用'],
+    ['retain', '持有', '保留'],
+    ['release', '释放'],
+    ['reference', '引用'],
+    // Common concepts
+    ['network', '网络'],
+    ['cache', 'caching', '缓存'],
+    ['persist', 'persistence', '持久化'],
+    ['serialize', 'serialization', '序列化'],
+    ['validate', 'validation', '校验', '验证'],
+    ['authenticate', 'authentication', '认证'],
+    ['authorize', 'authorization', '授权'],
+    ['config', 'configuration', '配置'],
+    ['navigate', 'navigation', '导航'],
+    ['animate', 'animation', '动画'],
+    ['layout', '布局'],
+    ['render', 'rendering', '渲染'],
+    ['responsive', '响应式'],
+    ['state', '状态'],
+    ['toast', '提示'],
+    ['error', '错误'],
+    ['handle', 'handler', '处理'],
+    ['service', '服务'],
+    ['test', 'testing', '测试'],
+];
+/** Lookup: lowercased term → synonym expansions (excluding the term itself) */
+const SYNONYM_LOOKUP = new Map();
+for (const group of SYNONYM_GROUPS) {
+    for (const term of group) {
+        SYNONYM_LOOKUP.set(term.toLowerCase(), group.filter((t) => t !== term));
+    }
+}
 // ── Public API ──────────────────────────────────────
 /**
  * Extract intent signals from user query and active file.
@@ -36,11 +112,13 @@ const LANG_MAP = {
  */
 export function extract(userQuery, activeFile, language, termOpts) {
     const queries = buildQueries(userQuery, activeFile, termOpts);
+    const keywordQueries = buildKeywordQueries(userQuery);
     const inferredLang = language || (activeFile ? inferLanguage(activeFile) : null);
     const module = activeFile ? inferFileContext(activeFile) : null;
     const scenario = classifyScenario(userQuery);
     return {
         queries,
+        keywordQueries,
         language: inferredLang,
         module,
         scenario,
@@ -49,14 +127,28 @@ export function extract(userQuery, activeFile, language, termOpts) {
 }
 /**
  * Build multi-query set from user query + active file.
- * Q1: raw query, Q2: extracted tech terms, Q3: file context.
+ * Q1: raw query, Q2: extracted tech terms, Q3: file context, Q4: synonym focus.
+ * Q1 is enriched with cross-language synonyms to bridge EN↔CJK matching.
+ * Q4 (long queries only): synonym expansion as a separate focused query
+ * to prevent BM25 dilution in verbose natural language inputs.
  */
 export function buildQueries(userQuery, activeFile, termOpts) {
-    const queries = [userQuery];
+    // Enrich raw query with cross-language synonyms
+    const synonyms = expandWithSynonyms(userQuery);
+    const enrichedQuery = synonyms ? `${userQuery} ${synonyms}` : userQuery;
+    const queries = [enrichedQuery];
     const terms = extractTechTerms(userQuery, termOpts);
     if (terms.length > 0) {
         queries.push(terms.join(' '));
     }
+    // Q4: For long queries (> 50 chars), add cross-language synonyms as a
+    // separate focused query. In long sentences, synonym terms appended to Q1
+    // get diluted by common words ("ViewController", "ViewModel"), causing
+    // BM25 to miss the user's actual intent. A short focused query matches
+    // domain-specific terms (e.g. "singleton 单例 inject 注入") directly.
+    if (synonyms && userQuery.length > 50) {
+        queries.push(synonyms);
+    }
     if (activeFile) {
         const ctx = inferFileContext(activeFile);
         if (ctx) {
@@ -65,6 +157,14 @@ export function buildQueries(userQuery, activeFile, termOpts) {
     }
     return queries;
 }
+/**
+ * Build keyword-mode queries for cross-language synonym matching.
+ * Uses keyword mode to preserve raw FWS scores without CoarseRanker semantic normalization.
+ */
+export function buildKeywordQueries(userQuery) {
+    const expanded = expandWithSynonyms(userQuery);
+    return expanded ? [expanded] : [];
+}
 /**
  * Extract tech terms from query using universal patterns + dynamic project prefixes.
  */
@@ -120,7 +220,7 @@ export function inferLanguage(filePath) {
  */
 export function classifyScenario(userQuery) {
     const q = userQuery.toLowerCase();
-    if (/帮我[加写做实现创建]|implement|add|create|新[增加建]/.test(q)) {
+    if (/帮我[加写做实现创建]|implement|add|create|新[增加建]|添加|修改|删除|实现|开发|编写|创建|初始化/.test(q)) {
         return 'generate';
     }
     if (/检查|review|lint|合规|违规|guard|规[则范]/.test(q)) {
@@ -132,6 +232,40 @@ export function classifyScenario(userQuery) {
     return 'search';
 }
 // ── Internal Helpers ────────────────────────────────
+/**
+ * Expand query tokens with cross-language synonyms.
+ * Tokenizes query, looks up each token in the synonym table,
+ * returns a query string of synonym expansions for cross-language matching.
+ *
+ * Strategy: per-token cross-script expansion. Each token's script is checked
+ * individually, and only synonyms in the OPPOSITE script are added.
+ * This correctly handles mixed EN/CJK queries (e.g. "在 module 里用 singleton")
+ * where both EN→CJK and CJK→EN expansions are needed.
+ */
+function expandWithSynonyms(query) {
+    const tokens = tokenize(query);
+    const crossScriptTerms = new Set();
+    const CJK_RE = /[\u4e00-\u9fff\u3400-\u4dbf]/;
+    for (const token of tokens) {
+        const synonyms = SYNONYM_LOOKUP.get(token.toLowerCase());
+        if (!synonyms) {
+            continue;
+        }
+        // Determine THIS token's script, not the whole query's
+        const tokenIsCJK = CJK_RE.test(token);
+        for (const syn of synonyms) {
+            const synIsCJK = CJK_RE.test(syn);
+            // Cross-script: EN token → add CJK synonyms; CJK token → add EN synonyms
+            if (tokenIsCJK !== synIsCJK) {
+                crossScriptTerms.add(syn);
+            }
+        }
+    }
+    if (crossScriptTerms.size === 0) {
+        return null;
+    }
+    return [...crossScriptTerms].slice(0, 16).join(' ');
+}
 function buildPrefixPattern(prefixes) {
     if (prefixes.length === 0) {
         return null;

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

@@ -8,7 +8,12 @@
  */
 import { slimSearchResult } from '#service/search/SearchTypes.js';
 // ── Constants ───────────────────────────────────────
-const RELEVANCE_THRESHOLD = 0.44;
+/** Absolute minimum score — items below this are definitely noise */
+const MIN_SCORE_THRESHOLD = 0.3;
+/** Relative threshold — items scoring below this fraction of the best result are dropped */
+const RELATIVE_SCORE_RATIO = 0.15;
+/** Gap ratio — if score drops by more than this factor from the previous item, truncate */
+const GAP_DROP_RATIO = 0.25;
 // ── PrimeSearchPipeline ─────────────────────────────
 export class PrimeSearchPipeline {
     #search;
@@ -29,10 +34,10 @@ export class PrimeSearchPipeline {
             intent: intent.scenario,
             sessionHistory: this.#buildSessionHistory(),
         };
-        // Multi-query parallel search
-        const allResults = await this.#multiQuerySearch(intent.queries, context);
-        // Threshold filter
-        const filtered = allResults.filter((r) => (r.score ?? 0) >= RELEVANCE_THRESHOLD);
+        // Multi-query parallel search (auto mode + keyword mode for cross-language)
+        const allResults = await this.#multiQuerySearch(intent.queries, intent.keywordQueries ?? [], context);
+        // Quality filter: absolute threshold + relative-to-best + score gap detection
+        const filtered = this.#qualityFilter(allResults);
         if (filtered.length === 0) {
             return null;
         }
@@ -62,32 +67,97 @@ export class PrimeSearchPipeline {
     }
     // ── Private ───────────────────────────────────────
     /**
-     * Multi-query parallel search + de-dup by ID (keep highest score).
+     * Quality filter: absolute threshold + relative-to-best + score gap detection.
+     * Expects items sorted by score descending.
      */
-    async #multiQuerySearch(queries, context) {
-        const promises = queries.map((q) => this.#search
-            .search(q, {
-            mode: 'auto',
-            limit: 8,
-            rank: true,
-            context,
-        })
+    #qualityFilter(items) {
+        if (items.length === 0) {
+            return [];
+        }
+        const maxScore = items[0]?.score ?? 0;
+        const effectiveThreshold = Math.max(MIN_SCORE_THRESHOLD, maxScore * RELATIVE_SCORE_RATIO);
+        const result = [];
+        let prevScore = maxScore;
+        for (const item of items) {
+            const score = item.score;
+            if (score < effectiveThreshold) {
+                break;
+            }
+            // Gap detection: if score drops sharply from previous item, stop
+            if (result.length > 0 && score < prevScore * GAP_DROP_RATIO) {
+                break;
+            }
+            result.push(item);
+            prevScore = score;
+        }
+        return result;
+    }
+    /**
+     * Multi-query parallel search with optional Reciprocal Rank Fusion (RRF).
+     *
+     * Single-query: preserves original search engine scores (BM25/CoarseRanker).
+     * Multi-query: uses RRF to fuse results, but weights by original score to
+     * retain magnitude information.
+     */
+    async #multiQuerySearch(autoQueries, keywordQueries, context) {
+        // Auto-mode searches (BM25 without CoarseRanker ranking)
+        // Using rank: false preserves raw BM25/FWS score magnitude,
+        // which the quality filter needs for effective discrimination.
+        // CoarseRanker's max-normalization + freshness/popularity signals
+        // would cluster scores around 0.35–0.41, defeating the filter.
+        const autoPromises = autoQueries.map((q) => this.#search
+            .search(q, { mode: 'auto', limit: 8, rank: false, context })
+            .catch(() => ({ 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 responses = await Promise.all(promises);
-        // Merge by ID, keep highest score
-        const bestById = new Map();
-        for (const resp of responses) {
-            const items = resp.items || [];
-            for (const raw of items) {
+        const [autoResponses, kwResponses] = await Promise.all([
+            Promise.all(autoPromises),
+            Promise.all(kwPromises),
+        ]);
+        const allResponses = [...autoResponses, ...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.
+        if (allResponses.length === 1) {
+            const items = (allResponses[0]?.items || []);
+            return items.map(slimSearchResult).sort((a, b) => b.score - a.score);
+        }
+        // Multi-query: Weighted RRF — RRF(d) = Σ origScore / (k + rank)
+        // Retains original score magnitude while still boosting cross-query overlap.
+        const RRF_K = 60;
+        const rrfScores = new Map();
+        const itemById = new Map();
+        for (const resp of allResponses) {
+            const items = (resp.items || []);
+            for (let rank = 0; rank < items.length; rank++) {
+                const raw = items[rank];
+                const origScore = Math.max(raw.score || 0, 0.01);
                 const item = slimSearchResult(raw);
-                const existing = bestById.get(item.id);
-                if (!existing || item.score > existing.score) {
-                    bestById.set(item.id, item);
+                rrfScores.set(item.id, (rrfScores.get(item.id) ?? 0) + origScore / (RRF_K + rank));
+                // Keep the richest metadata version
+                if (!itemById.has(item.id)) {
+                    itemById.set(item.id, item);
                 }
             }
         }
-        // Sort by score descending
-        return [...bestById.values()].sort((a, b) => b.score - a.score);
+        // Assign fused scores and sort
+        // Rescale: RRF_K division crushes scores to ~0.003–0.02 range,
+        // which falls below qualityFilter's MIN_SCORE_THRESHOLD (0.1).
+        // Multiply by RRF_K to restore original score magnitude.
+        // Effective formula: Σ origScore / (1 + rank/K), preserving magnitude
+        // while still giving a gentle rank-based discount.
+        const results = [];
+        for (const [id, rrfScore] of rrfScores) {
+            const item = itemById.get(id);
+            if (!item) {
+                continue;
+            }
+            item.score = Math.round(rrfScore * RRF_K * 1000) / 1000;
+            results.push(item);
+        }
+        return results.sort((a, b) => b.score - a.score);
     }
     /**
      * Build sessionHistory for contextBoost (last 5 queries).

package/dist/lib/service/vector/VectorService.d.ts

@@ -109,6 +109,9 @@ export declare class VectorService {
     /**
      * 混合搜索 (Dense + Sparse RRF 融合)
      * 通过 HybridRetriever 执行向量 + BM25 关键词并行检索
+     *
+     * Embed 失败时优雅降级: 跳过 Dense 路, 仅用 Sparse 结果进行 RRF 融合,
+     * 避免因网络问题导致整个搜索返回空结果。
      */
     hybridSearch(query: string, opts?: {
         topK?: number;

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

@@ -26,6 +26,11 @@ export class VectorService {
     #syncDebounceMs;
     #logger = Logger.getInstance();
     #initialized = false;
+    // ── Embed circuit breaker ──
+    #embedConsecutiveFailures = 0;
+    #embedCircuitOpenUntil = 0;
+    static #EMBED_CIRCUIT_THRESHOLD = 3;
+    static #EMBED_CIRCUIT_COOLDOWN_MS = 60_000;
     constructor(config) {
         this.#vectorStore = config.vectorStore;
         this.#indexingPipeline = config.indexingPipeline;
@@ -211,6 +216,9 @@ export class VectorService {
     /**
      * 混合搜索 (Dense + Sparse RRF 融合)
      * 通过 HybridRetriever 执行向量 + BM25 关键词并行检索
+     *
+     * Embed 失败时优雅降级: 跳过 Dense 路, 仅用 Sparse 结果进行 RRF 融合,
+     * 避免因网络问题导致整个搜索返回空结果。
      */
     async hybridSearch(query, opts = {}) {
         if (!this.#embedProvider) {
@@ -226,11 +234,37 @@ export class VectorService {
             }));
         }
         const { topK = 10, alpha = 0.5, sparseSearchFn = null } = opts;
+        // Embed query — circuit breaker skips embed after repeated failures
+        let queryVector = null;
+        const circuitOpen = Date.now() < this.#embedCircuitOpenUntil;
+        if (circuitOpen) {
+            this.#logger.debug('[VectorService] embed circuit open, skipping embed');
+        }
+        else {
+            try {
+                const embedResult = await this.#embedProvider.embed(query);
+                queryVector = Array.isArray(embedResult[0])
+                    ? embedResult[0]
+                    : embedResult;
+                this.#embedConsecutiveFailures = 0;
+            }
+            catch (err) {
+                this.#embedConsecutiveFailures++;
+                if (this.#embedConsecutiveFailures >= VectorService.#EMBED_CIRCUIT_THRESHOLD) {
+                    this.#embedCircuitOpenUntil = Date.now() + VectorService.#EMBED_CIRCUIT_COOLDOWN_MS;
+                    this.#logger.warn('[VectorService] embed circuit OPEN — skipping embed for 60s', {
+                        consecutiveFailures: this.#embedConsecutiveFailures,
+                    });
+                }
+                else {
+                    this.#logger.warn('[VectorService] embed failed, degrading to sparse-only', {
+                        error: err instanceof Error ? err.message : String(err),
+                        failCount: this.#embedConsecutiveFailures,
+                    });
+                }
+            }
+        }
         try {
-            const embedResult = await this.#embedProvider.embed(query);
-            const queryVector = Array.isArray(embedResult[0])
-                ? embedResult[0]
-                : embedResult;
             const fused = await this.#hybridRetriever.search(query, queryVector, {
                 topK,
                 alpha,

package/dist/lib/shared/schemas/mcp-tools.d.ts

@@ -247,6 +247,7 @@ export declare const TaskInput: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     id: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
     reason: z.ZodOptional<z.ZodString>;
     rationale: z.ZodOptional<z.ZodString>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/lib/shared/schemas/mcp-tools.js

@@ -235,7 +235,11 @@ export const TaskInput = z.object({
         .describe('prime=加载知识上下文 | create=创建任务锚点 | close=完成+Guard | fail=放弃 | record_decision=记录用户偏好'),
     title: z.string().optional().describe('Task or decision title (create / record_decision)'),
     description: z.string().optional().describe('Decision description (record_decision)'),
-    id: z.string().optional().describe('Task ID (close / fail)'),
+    id: z
+        .string()
+        .optional()
+        .describe('Task ID (close / fail). Optional if a task was created in the current session.'),
+    taskId: z.string().optional().describe('Alias for id (accepted for convenience)'),
     reason: z.string().optional().describe('Close reason or fail reason'),
     rationale: z.string().optional().describe('Decision rationale (record_decision)'),
     tags: z.array(z.string()).optional().describe('Decision tags (record_decision)'),

package/package.json

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