autosnippet 3.3.0 → 3.3.3

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

@@ -0,0 +1,256 @@
+/**
+ * IntentExtractor — Intake Layer
+ *
+ * Pure functions: extract intent signals from user query + active file.
+ * Builds multi-query set, infers language/module/scenario for search routing.
+ *
+ * @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
+    /`([^`]+)`/g, // backtick code
+    /\b[\w-]+\.(?:ts|js|m|h|swift|py|java|go|rs|tsx|kt)\b/g, // file names
+    /@[\w-]+/g, // trigger references
+];
+// ── Language Extension Map ──────────────────────────
+const LANG_MAP = {
+    m: 'objectivec',
+    h: 'objectivec',
+    mm: 'objectivec',
+    swift: 'swift',
+    ts: 'typescript',
+    tsx: 'typescript',
+    js: 'javascript',
+    jsx: 'javascript',
+    py: 'python',
+    go: 'go',
+    rs: 'rust',
+    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', '并发'],
+    // 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.
+ * Pure function — no side effects, no DI.
+ */
+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,
+        raw: { userQuery, activeFile, language },
+    };
+}
+/**
+ * Build multi-query set from user query + active file.
+ * Q1: raw query, Q2: extracted tech terms, Q3: file context.
+ * Q1 is enriched with cross-language synonyms to bridge EN↔CJK matching.
+ */
+export function buildQueries(userQuery, activeFile, termOpts) {
+    // 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(' '));
+    }
+    if (activeFile) {
+        const ctx = inferFileContext(activeFile);
+        if (ctx) {
+            queries.push(ctx);
+        }
+    }
+    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.
+ */
+export function extractTechTerms(query, opts = {}) {
+    const terms = new Set();
+    // 1. Universal patterns (always run)
+    for (const pattern of UNIVERSAL_PATTERNS) {
+        for (const match of query.matchAll(new RegExp(pattern.source, pattern.flags))) {
+            const term = match[1] || match[0];
+            if (term.length >= 3 && term.length <= 50) {
+                terms.add(term);
+            }
+        }
+    }
+    // 2. Project prefix patterns (dynamic)
+    const allPrefixes = [...(opts.projectPrefixes ?? []), ...(opts.platformPrefixes ?? [])];
+    const prefixPattern = buildPrefixPattern(allPrefixes);
+    if (prefixPattern) {
+        for (const match of query.matchAll(prefixPattern)) {
+            if (match[0].length >= 3 && match[0].length <= 50) {
+                terms.add(match[0]);
+            }
+        }
+    }
+    return [...terms].slice(0, 8);
+}
+/**
+ * Infer file context string from file path for search augmentation.
+ * Returns module path + class name, e.g. "Services/Network BDNetworkManager"
+ */
+export function inferFileContext(filePath) {
+    const parts = filePath.replace(/\\/g, '/').split('/');
+    const fileName = parts[parts.length - 1] || '';
+    // Extract class name (remove extension)
+    const className = fileName.replace(/\.\w+$/, '');
+    // Extract meaningful module path (skip root dir and file name)
+    const meaningful = parts
+        .slice(1, -1)
+        .filter((p) => !['src', 'lib', 'Sources', 'BiliDili', 'BiliDemo'].includes(p));
+    const module = meaningful.slice(0, 2).join('/');
+    const segments = [module, className].filter(Boolean);
+    return segments.length > 0 ? segments.join(' ') : null;
+}
+/**
+ * Infer language from file extension.
+ */
+export function inferLanguage(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    return ext ? (LANG_MAP[ext] ?? null) : null;
+}
+/**
+ * Classify search scenario from user query (lightweight rule-based).
+ */
+export function classifyScenario(userQuery) {
+    const q = userQuery.toLowerCase();
+    if (/帮我[加写做实现创建]|implement|add|create|新[增加建]/.test(q)) {
+        return 'generate';
+    }
+    if (/检查|review|lint|合规|违规|guard|规[则范]/.test(q)) {
+        return 'lint';
+    }
+    if (/什么是|怎么[用做]|原理|explain|学习|理解|为什么/.test(q)) {
+        return 'learning';
+    }
+    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: return only cross-script synonyms (EN→CJK or CJK→EN).
+ * This keeps the expansion focused — the original script tokens are already in Q1.
+ */
+function expandWithSynonyms(query) {
+    const tokens = tokenize(query);
+    const crossScriptTerms = new Set();
+    // Detect query script: does it contain CJK?
+    const hasCJK = /[\u4e00-\u9fff\u3400-\u4dbf]/.test(query);
+    for (const token of tokens) {
+        const synonyms = SYNONYM_LOOKUP.get(token.toLowerCase());
+        if (!synonyms) {
+            continue;
+        }
+        for (const syn of synonyms) {
+            const synIsCJK = /[\u4e00-\u9fff\u3400-\u4dbf]/.test(syn);
+            // Cross-script: EN query → add CJK synonyms; CJK query → add EN synonyms
+            if (hasCJK !== synIsCJK) {
+                crossScriptTerms.add(syn);
+            }
+        }
+    }
+    if (crossScriptTerms.size === 0) {
+        return null;
+    }
+    return [...crossScriptTerms].slice(0, 12).join(' ');
+}
+function buildPrefixPattern(prefixes) {
+    if (prefixes.length === 0) {
+        return null;
+    }
+    const sorted = [...prefixes].sort((a, b) => b.length - a.length);
+    const escaped = sorted.map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    return new RegExp(`\\b(?:${escaped.join('|')})\\w{2,}\\b`, 'g');
+}

package/dist/lib/service/task/PrimeSearchPipeline.d.ts

@@ -0,0 +1,54 @@
+/**
+ * PrimeSearchPipeline — Enrichment Layer
+ *
+ * Multi-query parallel search + scenario routing + session history accumulation.
+ * Replaces TaskKnowledgeBridge with full search pipeline integration.
+ *
+ * @module service/task/PrimeSearchPipeline
+ */
+import type { SlimSearchResult } from '#service/search/SearchTypes.js';
+import type { ExtractedIntent } from './IntentExtractor.js';
+/** Slim search result (re-export for external use) */
+export type { SlimSearchResult } from '#service/search/SearchTypes.js';
+export interface PrimeSearchMeta {
+    queries: string[];
+    scenario: string;
+    language: string | null;
+    module: string | null;
+    resultCount: number;
+    filteredCount: number;
+}
+export interface PrimeSearchResult {
+    relatedKnowledge: SlimSearchResult[];
+    guardRules: SlimSearchResult[];
+    searchMeta: PrimeSearchMeta;
+}
+/** Minimal SearchEngine shape — duck-typed for DI flexibility */
+interface SearchEngineLike {
+    search(query: string, options?: {
+        mode?: string;
+        limit?: number;
+        rank?: boolean;
+        context?: {
+            sessionHistory?: Array<{
+                content?: string;
+            }>;
+            language?: string;
+            intent?: string;
+        };
+    }): Promise<{
+        items?: unknown[];
+    }>;
+}
+export declare class PrimeSearchPipeline {
+    #private;
+    constructor(searchEngine: SearchEngineLike);
+    /**
+     * Core method: multi-query search + scenario routing + result merging.
+     */
+    search(intent: ExtractedIntent): Promise<PrimeSearchResult | null>;
+    /**
+     * Reset session history (called on new session start).
+     */
+    resetSession(): void;
+}

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

@@ -0,0 +1,113 @@
+/**
+ * PrimeSearchPipeline — Enrichment Layer
+ *
+ * Multi-query parallel search + scenario routing + session history accumulation.
+ * Replaces TaskKnowledgeBridge with full search pipeline integration.
+ *
+ * @module service/task/PrimeSearchPipeline
+ */
+import { slimSearchResult } from '#service/search/SearchTypes.js';
+// ── Constants ───────────────────────────────────────
+const RELEVANCE_THRESHOLD = 0.01;
+// ── PrimeSearchPipeline ─────────────────────────────
+export class PrimeSearchPipeline {
+    #search;
+    #sessionQueries = [];
+    constructor(searchEngine) {
+        this.#search = searchEngine;
+    }
+    /**
+     * Core method: multi-query search + scenario routing + result merging.
+     */
+    async search(intent) {
+        if (!intent.queries.length || !intent.queries[0]?.trim()) {
+            return null;
+        }
+        // Build ranking context
+        const context = {
+            language: intent.language ?? undefined,
+            intent: intent.scenario,
+            sessionHistory: this.#buildSessionHistory(),
+        };
+        // Multi-query parallel search (auto mode + keyword mode for cross-language)
+        const allResults = await this.#multiQuerySearch(intent.queries, intent.keywordQueries ?? [], context);
+        // Threshold filter
+        const filtered = allResults.filter((r) => (r.score ?? 0) >= RELEVANCE_THRESHOLD);
+        if (filtered.length === 0) {
+            return null;
+        }
+        // Classify: knowledge vs rules
+        const knowledge = filtered.filter((r) => r.kind !== 'rule').slice(0, 5);
+        const rules = filtered.filter((r) => r.kind === 'rule').slice(0, 3);
+        // Record search to session history
+        this.#sessionQueries.push(intent.raw.userQuery);
+        return {
+            relatedKnowledge: knowledge,
+            guardRules: rules,
+            searchMeta: {
+                queries: intent.queries,
+                scenario: intent.scenario,
+                language: intent.language,
+                module: intent.module,
+                resultCount: allResults.length,
+                filteredCount: filtered.length,
+            },
+        };
+    }
+    /**
+     * Reset session history (called on new session start).
+     */
+    resetSession() {
+        this.#sessionQueries = [];
+    }
+    // ── Private ───────────────────────────────────────
+    /**
+     * Multi-query parallel search with Reciprocal Rank Fusion (RRF).
+     * Auto-mode queries use CoarseRanker; keyword queries use raw FWS scores.
+     * Results are fused by rank position, not absolute scores — robust across heterogeneous scorers.
+     */
+    async #multiQuerySearch(autoQueries, keywordQueries, context) {
+        // Auto-mode searches (full CoarseRanker pipeline)
+        const autoPromises = autoQueries.map((q) => this.#search
+            .search(q, { mode: 'auto', limit: 8, rank: true, 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 [autoResponses, kwResponses] = await Promise.all([
+            Promise.all(autoPromises),
+            Promise.all(kwPromises),
+        ]);
+        const allResponses = [...autoResponses, ...kwResponses];
+        // Reciprocal Rank Fusion: RRF(d) = Σ 1/(k + rank)
+        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 item = slimSearchResult(items[rank]);
+                rrfScores.set(item.id, (rrfScores.get(item.id) ?? 0) + 1 / (RRF_K + rank));
+                // Keep the richest metadata version
+                if (!itemById.has(item.id)) {
+                    itemById.set(item.id, item);
+                }
+            }
+        }
+        // Assign fused scores and sort
+        const results = [];
+        for (const [id, rrfScore] of rrfScores) {
+            const item = itemById.get(id);
+            item.score = rrfScore;
+            results.push(item);
+        }
+        return results.sort((a, b) => b.score - a.score);
+    }
+    /**
+     * Build sessionHistory for contextBoost (last 5 queries).
+     */
+    #buildSessionHistory() {
+        return this.#sessionQueries.slice(-5).map((q) => ({ content: q }));
+    }
+}

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,