distill-mcp 0.6.0-beta

package/dist/utils/error-normalizer.js

@@ -0,0 +1,233 @@
+/**
+ * Error Normalizer
+ *
+ * Normalizes error lines to create consistent signatures for deduplication.
+ * Removes variable parts (file paths, line numbers, values) while preserving
+ * the error pattern.
+ */
+/**
+ * Normalize an error line by replacing variable parts with placeholders.
+ * This creates a consistent signature for grouping similar errors.
+ */
+export function normalizeErrorLine(line) {
+    return (line
+        // Remove file paths (Unix and Windows)
+        .replace(/[A-Za-z]:\\[\w\-\\\.]+\.(ts|tsx|js|jsx|py|go|rs|java|c|cpp|h|hpp)/gi, "<FILE>")
+        .replace(/\/[\w\-\.\/]+\.(ts|tsx|js|jsx|py|go|rs|java|c|cpp|h|hpp)/g, "<FILE>")
+        // Remove relative paths
+        .replace(/\.\.?\/[\w\-\.\/]+\.(ts|tsx|js|jsx|py|go|rs|java|c|cpp|h|hpp)/g, "<FILE>")
+        // Remove line:column patterns
+        .replace(/:\d+:\d+/g, ":<LINE>")
+        .replace(/\(\d+,\s*\d+\)/g, "(<LINE>)")
+        .replace(/\[\d+,\s*\d+\]/g, "[<LINE>]")
+        .replace(/line\s+\d+/gi, "line <LINE>")
+        .replace(/col(?:umn)?\s+\d+/gi, "col <LINE>")
+        // Remove quoted values (but preserve the quotes for structure)
+        .replace(/'[^']*'/g, "'<VALUE>'")
+        .replace(/"[^"]*"/g, '"<VALUE>"')
+        .replace(/`[^`]*`/g, "`<VALUE>`")
+        // Remove timestamps
+        .replace(/\d{4}-\d{2}-\d{2}[\sT]\d{2}:\d{2}:\d{2}(\.\d+)?([+-]\d{2}:?\d{2}|Z)?/g, "<TIMESTAMP>")
+        .replace(/\d{2}\/\d{2}\/\d{4}\s+\d{2}:\d{2}:\d{2}/g, "<TIMESTAMP>")
+        // Remove numeric IDs and hashes
+        .replace(/\b[0-9a-f]{32,}\b/gi, "<HASH>")
+        .replace(/\b\d{5,}\b/g, "<ID>")
+        // Normalize whitespace
+        .replace(/\s+/g, " ")
+        .trim());
+}
+/**
+ * Common error patterns for different tools
+ */
+const ERROR_PATTERNS = [
+    // TypeScript: src/file.ts(12,5): error TS2304: Cannot find name 'foo'.
+    {
+        name: "typescript",
+        regex: /^(.+?)\((\d+),(\d+)\):\s*(error|warning)\s+(TS\d+):\s*(.+)$/,
+        extract: (match) => ({
+            file: match[1] ?? "",
+            line: parseInt(match[2] ?? "0", 10),
+            column: parseInt(match[3] ?? "0", 10),
+            code: match[5] ?? "",
+            message: match[6] ?? "",
+            raw: match[0] ?? "",
+        }),
+    },
+    // ESLint: src/file.ts:12:5 - error rule-name: Message
+    {
+        name: "eslint",
+        regex: /^(.+?):(\d+):(\d+)\s*-?\s*(error|warning|info)\s+([a-z\-@\/]+):\s*(.+)$/i,
+        extract: (match) => ({
+            file: match[1] ?? "",
+            line: parseInt(match[2] ?? "0", 10),
+            column: parseInt(match[3] ?? "0", 10),
+            code: match[5] ?? "",
+            message: match[6] ?? "",
+            raw: match[0] ?? "",
+        }),
+    },
+    // GCC/Clang: file.c:12:5: error: message
+    {
+        name: "gcc",
+        regex: /^(.+?):(\d+):(\d+):\s*(error|warning|note):\s*(.+)$/,
+        extract: (match) => ({
+            file: match[1] ?? "",
+            line: parseInt(match[2] ?? "0", 10),
+            column: parseInt(match[3] ?? "0", 10),
+            code: match[4] ?? "",
+            message: match[5] ?? "",
+            raw: match[0] ?? "",
+        }),
+    },
+    // Python: File "file.py", line 12, in function
+    {
+        name: "python",
+        regex: /^File "(.+?)", line (\d+)(?:, in .+)?$/,
+        extract: (match) => ({
+            file: match[1] ?? "",
+            line: parseInt(match[2] ?? "0", 10),
+            message: match[0] ?? "",
+            raw: match[0] ?? "",
+        }),
+    },
+    // Python error: ErrorType: message
+    {
+        name: "python-error",
+        regex: /^([A-Z][a-zA-Z]+Error):\s*(.+)$/,
+        extract: (match) => ({
+            code: match[1] ?? "",
+            message: match[2] ?? "",
+            raw: match[0] ?? "",
+        }),
+    },
+    // Go: file.go:12:5: message
+    {
+        name: "go",
+        regex: /^(.+?\.go):(\d+):(\d+):\s*(.+)$/,
+        extract: (match) => ({
+            file: match[1] ?? "",
+            line: parseInt(match[2] ?? "0", 10),
+            column: parseInt(match[3] ?? "0", 10),
+            message: match[4] ?? "",
+            raw: match[0] ?? "",
+        }),
+    },
+    // Rust: error[E0425]: cannot find value `x` in this scope
+    {
+        name: "rust",
+        regex: /^(error|warning)\[(E\d+)\]:\s*(.+)$/,
+        extract: (match) => ({
+            code: match[2] ?? "",
+            message: match[3] ?? "",
+            raw: match[0] ?? "",
+        }),
+    },
+    // Rust location: --> file.rs:12:5
+    {
+        name: "rust-location",
+        regex: /^\s*-->\s*(.+?):(\d+):(\d+)$/,
+        extract: (match) => ({
+            file: match[1] ?? "",
+            line: parseInt(match[2] ?? "0", 10),
+            column: parseInt(match[3] ?? "0", 10),
+            message: match[0] ?? "",
+            raw: match[0] ?? "",
+        }),
+    },
+    // Generic: [ERROR] message or ERROR: message
+    {
+        name: "generic-bracket",
+        regex: /^\[(ERROR|WARN(?:ING)?|INFO)\]\s*(.+)$/i,
+        extract: (match) => ({
+            code: (match[1] ?? "").toUpperCase(),
+            message: match[2] ?? "",
+            raw: match[0] ?? "",
+        }),
+    },
+    // Generic colon format
+    {
+        name: "generic-colon",
+        regex: /^(ERROR|WARN(?:ING)?|FATAL):\s*(.+)$/i,
+        extract: (match) => ({
+            code: (match[1] ?? "").toUpperCase(),
+            message: match[2] ?? "",
+            raw: match[0] ?? "",
+        }),
+    },
+];
+/**
+ * Extract structured parts from an error line.
+ * Returns null if the line doesn't match any known error pattern.
+ */
+export function extractErrorParts(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    for (const pattern of ERROR_PATTERNS) {
+        const match = trimmed.match(pattern.regex);
+        if (match) {
+            return pattern.extract(match);
+        }
+    }
+    // If no pattern matches but line looks like an error
+    if (isLikelyError(trimmed)) {
+        return {
+            message: trimmed,
+            raw: trimmed,
+        };
+    }
+    return null;
+}
+/**
+ * Check if a line is likely an error message
+ */
+export function isLikelyError(line) {
+    const errorIndicators = [
+        /\berror\b/i,
+        /\bfailed\b/i,
+        /\bfailure\b/i,
+        /\bexception\b/i,
+        /\bcannot\b/i,
+        /\bunable\b/i,
+        /\binvalid\b/i,
+        /\bunexpected\b/i,
+        /\bmissing\b/i,
+        /\bundefined\b/i,
+        /\bnot found\b/i,
+        /\bdoes not exist\b/i,
+        /\bnot defined\b/i,
+        /\btype mismatch\b/i,
+        /\bsyntax error\b/i,
+        /^\s*\^+\s*$/, // Error pointer line (^^^)
+    ];
+    return errorIndicators.some((pattern) => pattern.test(line));
+}
+/**
+ * Create a signature from error parts for grouping.
+ * The signature represents the "type" of error, ignoring location.
+ */
+export function createSignature(parts) {
+    const components = [];
+    if (parts.code) {
+        components.push(parts.code);
+    }
+    // Normalize the message
+    const normalizedMessage = normalizeErrorLine(parts.message);
+    components.push(normalizedMessage);
+    return components.join(": ");
+}
+/**
+ * Extract file location from error parts
+ */
+export function formatLocation(parts) {
+    if (!parts.file)
+        return "";
+    let location = parts.file;
+    if (parts.line !== undefined) {
+        location += `:${parts.line}`;
+        if (parts.column !== undefined) {
+            location += `:${parts.column}`;
+        }
+    }
+    return location;
+}

package/dist/utils/hybrid-search.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Hybrid Search combining BM25 (lexical) and Semantic Similarity
+ *
+ * Uses a weighted combination of:
+ * - BM25 for exact/partial keyword matches (40%)
+ * - Cosine similarity on embeddings for semantic matches (60%)
+ *
+ * This allows finding tools even when the query uses different
+ * words than the tool description (e.g., "shrink output" → compress).
+ */
+import { type BM25Result } from "./bm25.js";
+/**
+ * Configuration options for hybrid search
+ */
+export interface HybridSearchOptions {
+    /** Weight for BM25 lexical matching (default: 0.4) */
+    bm25Weight?: number;
+    /** Weight for semantic similarity (default: 0.6) */
+    semanticWeight?: number;
+    /** Minimum semantic similarity for semantic-only matches (default: 0.5) */
+    semanticThreshold?: number;
+}
+/**
+ * Result from hybrid search with both scores
+ */
+export interface HybridSearchResult<T> {
+    /** The matched item */
+    item: T;
+    /** Combined score (weighted BM25 + semantic) */
+    score: number;
+    /** Raw BM25 score */
+    bm25Score: number;
+    /** Semantic similarity score (0-1) */
+    semanticScore: number;
+    /** Terms that matched in BM25 */
+    matchedTerms: string[];
+}
+/**
+ * Hybrid search index interface
+ */
+export interface HybridSearchIndex<T> {
+    /** Search using hybrid BM25 + semantic */
+    search: (query: string) => Promise<HybridSearchResult<T>[]>;
+    /** Search using BM25 only (synchronous, always available) */
+    searchBM25Only: (query: string) => BM25Result<T>[];
+    /** Precompute embeddings for all items (call during idle time) */
+    precomputeEmbeddings: () => Promise<void>;
+    /** Check if semantic search is ready */
+    isSemanticReady: () => boolean;
+}
+/**
+ * Create a hybrid search index combining BM25 and semantic similarity
+ *
+ * @param items - Array of items to index
+ * @param getSearchableText - Function to extract text from each item
+ * @param options - Search configuration options
+ * @returns Hybrid search index
+ *
+ * @example
+ * ```typescript
+ * const tools = [
+ *   { name: "compress", description: "Compress and reduce output" },
+ *   { name: "analyze", description: "Analyze build errors" }
+ * ];
+ *
+ * const index = createHybridSearchIndex(
+ *   tools,
+ *   (tool) => `${tool.name} ${tool.description}`
+ * );
+ *
+ * // BM25 match
+ * await index.search("compress"); // finds "compress" tool
+ *
+ * // Semantic match (no keyword overlap)
+ * await index.search("shrink output"); // also finds "compress" tool!
+ * ```
+ */
+export declare function createHybridSearchIndex<T>(items: T[], getSearchableText: (item: T) => string, options?: HybridSearchOptions): HybridSearchIndex<T>;
+//# sourceMappingURL=hybrid-search.d.ts.map

package/dist/utils/hybrid-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hybrid-search.d.ts","sourceRoot":"","sources":["../../src/utils/hybrid-search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AAO7D;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2EAA2E;IAC3E,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC,uBAAuB;IACvB,IAAI,EAAE,CAAC,CAAC;IACR,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,qBAAqB;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,iCAAiC;IACjC,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC,0CAA0C;IAC1C,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC5D,6DAA6D;IAC7D,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;IACnD,kEAAkE;IAClE,oBAAoB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,wCAAwC;IACxC,eAAe,EAAE,MAAM,OAAO,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,KAAK,EAAE,CAAC,EAAE,EACV,iBAAiB,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EACtC,OAAO,CAAC,EAAE,mBAAmB,GAC5B,iBAAiB,CAAC,CAAC,CAAC,CA4HtB"}

package/dist/utils/hybrid-search.js

@@ -0,0 +1,146 @@
+/**
+ * Hybrid Search combining BM25 (lexical) and Semantic Similarity
+ *
+ * Uses a weighted combination of:
+ * - BM25 for exact/partial keyword matches (40%)
+ * - Cosine similarity on embeddings for semantic matches (60%)
+ *
+ * This allows finding tools even when the query uses different
+ * words than the tool description (e.g., "shrink output" → compress).
+ */
+import { createBM25Index } from "./bm25.js";
+import { computeEmbedding, computeEmbeddings, cosineSimilarity, } from "./embeddings.js";
+/**
+ * Create a hybrid search index combining BM25 and semantic similarity
+ *
+ * @param items - Array of items to index
+ * @param getSearchableText - Function to extract text from each item
+ * @param options - Search configuration options
+ * @returns Hybrid search index
+ *
+ * @example
+ * ```typescript
+ * const tools = [
+ *   { name: "compress", description: "Compress and reduce output" },
+ *   { name: "analyze", description: "Analyze build errors" }
+ * ];
+ *
+ * const index = createHybridSearchIndex(
+ *   tools,
+ *   (tool) => `${tool.name} ${tool.description}`
+ * );
+ *
+ * // BM25 match
+ * await index.search("compress"); // finds "compress" tool
+ *
+ * // Semantic match (no keyword overlap)
+ * await index.search("shrink output"); // also finds "compress" tool!
+ * ```
+ */
+export function createHybridSearchIndex(items, getSearchableText, options) {
+    const bm25Weight = options?.bm25Weight ?? 0.4;
+    const semanticWeight = options?.semanticWeight ?? 0.6;
+    const semanticThreshold = options?.semanticThreshold ?? 0.5;
+    // BM25 index (synchronous, always available)
+    const bm25Index = createBM25Index(items, getSearchableText);
+    // Item embeddings (lazy computed)
+    let itemEmbeddings = null;
+    let embeddingsPromise = null;
+    /**
+     * Ensure embeddings are computed
+     */
+    async function ensureEmbeddings() {
+        if (itemEmbeddings)
+            return itemEmbeddings;
+        if (!embeddingsPromise) {
+            embeddingsPromise = (async () => {
+                const texts = items.map(getSearchableText);
+                itemEmbeddings = await computeEmbeddings(texts);
+            })();
+        }
+        await embeddingsPromise;
+        return itemEmbeddings;
+    }
+    return {
+        async search(query) {
+            // Get BM25 results first (always available)
+            const bm25Results = bm25Index.search(query);
+            // Try to compute semantic scores
+            let queryEmbedding = null;
+            let embeddings = null;
+            try {
+                embeddings = await ensureEmbeddings();
+                queryEmbedding = await computeEmbedding(query);
+            }
+            catch {
+                // Semantic search failed, fall back to BM25 only
+                return bm25Results.map((r) => ({
+                    item: r.item,
+                    score: r.score,
+                    bm25Score: r.score,
+                    semanticScore: 0,
+                    matchedTerms: r.matchedTerms,
+                }));
+            }
+            // Build item index map for O(1) lookup
+            const itemIndexMap = new Map();
+            items.forEach((item, idx) => itemIndexMap.set(item, idx));
+            // Normalize BM25 scores to 0-1 range
+            const maxBM25 = Math.max(...bm25Results.map((r) => r.score), 0.001);
+            // Combine BM25 results with semantic scores
+            const results = [];
+            const processedItems = new Set();
+            for (const bm25Result of bm25Results) {
+                const idx = itemIndexMap.get(bm25Result.item);
+                if (idx === undefined || !embeddings || !queryEmbedding)
+                    continue;
+                const itemEmbedding = embeddings[idx];
+                if (!itemEmbedding)
+                    continue;
+                const semanticScore = cosineSimilarity(queryEmbedding, itemEmbedding);
+                const normalizedBM25 = bm25Result.score / maxBM25;
+                results.push({
+                    item: bm25Result.item,
+                    score: normalizedBM25 * bm25Weight + semanticScore * semanticWeight,
+                    bm25Score: bm25Result.score,
+                    semanticScore,
+                    matchedTerms: bm25Result.matchedTerms,
+                });
+                processedItems.add(bm25Result.item);
+            }
+            // Add items that only match semantically (no BM25 match)
+            if (embeddings && queryEmbedding) {
+                for (let i = 0; i < items.length; i++) {
+                    const item = items[i];
+                    if (!item || processedItems.has(item))
+                        continue;
+                    const itemEmbedding = embeddings[i];
+                    if (!itemEmbedding)
+                        continue;
+                    const similarity = cosineSimilarity(queryEmbedding, itemEmbedding);
+                    // Only include if above semantic threshold
+                    if (similarity >= semanticThreshold) {
+                        results.push({
+                            item,
+                            score: similarity * semanticWeight,
+                            bm25Score: 0,
+                            semanticScore: similarity,
+                            matchedTerms: [],
+                        });
+                    }
+                }
+            }
+            // Sort by combined score (highest first)
+            return results.sort((a, b) => b.score - a.score);
+        },
+        searchBM25Only(query) {
+            return bm25Index.search(query);
+        },
+        async precomputeEmbeddings() {
+            await ensureEmbeddings();
+        },
+        isSemanticReady() {
+            return itemEmbeddings !== null;
+        },
+    };
+}

package/dist/utils/hybrid-search.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hybrid Search Tests
+ */
+export {};
+//# sourceMappingURL=hybrid-search.test.d.ts.map

package/dist/utils/hybrid-search.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hybrid-search.test.d.ts","sourceRoot":"","sources":["../../src/utils/hybrid-search.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/utils/hybrid-search.test.js

@@ -0,0 +1,172 @@
+/**
+ * Hybrid Search Tests
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createHybridSearchIndex } from "./hybrid-search.js";
+// Mock the embeddings module for fast tests
+vi.mock("./embeddings.js", () => {
+    // Simple mock embeddings based on word overlap
+    const mockEmbedding = (text) => {
+        const words = text.toLowerCase().split(/\s+/);
+        const dim = 384;
+        const embedding = new Array(dim).fill(0);
+        // Create deterministic embedding based on words
+        for (const word of words) {
+            for (let i = 0; i < word.length; i++) {
+                const idx = (word.charCodeAt(i) * (i + 1)) % dim;
+                embedding[idx] += 0.1;
+            }
+        }
+        // Normalize
+        const magnitude = Math.sqrt(embedding.reduce((sum, x) => sum + x * x, 0));
+        if (magnitude > 0) {
+            for (let i = 0; i < dim; i++) {
+                embedding[i] /= magnitude;
+            }
+        }
+        return embedding;
+    };
+    return {
+        computeEmbedding: vi.fn(async (text) => mockEmbedding(text)),
+        computeEmbeddings: vi.fn(async (texts) => texts.map((t) => mockEmbedding(t))),
+        cosineSimilarity: vi.fn((a, b) => {
+            if (a.length !== b.length)
+                return 0;
+            let dot = 0;
+            for (let i = 0; i < a.length; i++) {
+                dot += (a[i] ?? 0) * (b[i] ?? 0);
+            }
+            return dot;
+        }),
+    };
+});
+describe("Hybrid Search", () => {
+    const testItems = [
+        { name: "compress", description: "Compress and reduce output size" },
+        { name: "analyze", description: "Analyze build errors and warnings" },
+        { name: "summarize", description: "Summarize log files" },
+        { name: "optimize", description: "Optimize token usage" },
+    ];
+    const getSearchableText = (item) => `${item.name} ${item.description}`;
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe("createHybridSearchIndex", () => {
+        it("should create an index with all methods", () => {
+            const index = createHybridSearchIndex(testItems, getSearchableText);
+            expect(index.search).toBeDefined();
+            expect(index.searchBM25Only).toBeDefined();
+            expect(index.precomputeEmbeddings).toBeDefined();
+            expect(index.isSemanticReady).toBeDefined();
+        });
+        it("should start with semantic not ready", () => {
+            const index = createHybridSearchIndex(testItems, getSearchableText);
+            expect(index.isSemanticReady()).toBe(false);
+        });
+    });
+    describe("searchBM25Only", () => {
+        it("should return BM25 results synchronously", () => {
+            const index = createHybridSearchIndex(testItems, getSearchableText);
+            const results = index.searchBM25Only("compress");
+            expect(results.length).toBeGreaterThan(0);
+            expect(results[0].item.name).toBe("compress");
+        });
+        it("should return empty array for no matches", () => {
+            const index = createHybridSearchIndex(testItems, getSearchableText);
+            const results = index.searchBM25Only("nonexistent");
+            expect(results).toHaveLength(0);
+        });
+    });
+    describe("search (hybrid)", () => {
+        it("should return results with both BM25 and semantic scores", async () => {
+            const index = createHybridSearchIndex(testItems, getSearchableText);
+            const results = await index.search("compress output");
+            expect(results.length).toBeGreaterThan(0);
+            expect(results[0]).toHaveProperty("bm25Score");
+            expect(results[0]).toHaveProperty("semanticScore");
+            expect(results[0]).toHaveProperty("score");
+            expect(results[0]).toHaveProperty("matchedTerms");
+        });
+        it("should find exact keyword matches", async () => {
+            const index = createHybridSearchIndex(testItems, getSearchableText);
+            const results = await index.search("compress");
+            expect(results.length).toBeGreaterThan(0);
+            expect(results[0].item.name).toBe("compress");
+            expect(results[0].bm25Score).toBeGreaterThan(0);
+        });
+        it("should sort results by combined score", async () => {
+            const index = createHybridSearchIndex(testItems, getSearchableText);
+            const results = await index.search("compress reduce");
+            for (let i = 1; i < results.length; i++) {
+                expect(results[i - 1].score).toBeGreaterThanOrEqual(results[i].score);
+            }
+        });
+        it("should handle empty query", async () => {
+            const index = createHybridSearchIndex(testItems, getSearchableText);
+            const results = await index.search("");
+            // Empty query might return all items with semantic similarity
+            // or no results depending on implementation
+            expect(Array.isArray(results)).toBe(true);
+        });
+        it("should use custom weights", async () => {
+            const index = createHybridSearchIndex(testItems, getSearchableText, {
+                bm25Weight: 0.8,
+                semanticWeight: 0.2,
+            });
+            const results = await index.search("compress");
+            expect(results.length).toBeGreaterThan(0);
+        });
+    });
+    describe("precomputeEmbeddings", () => {
+        it("should mark semantic as ready after precomputing", async () => {
+            const index = createHybridSearchIndex(testItems, getSearchableText);
+            expect(index.isSemanticReady()).toBe(false);
+            await index.precomputeEmbeddings();
+            expect(index.isSemanticReady()).toBe(true);
+        });
+        it("should only compute embeddings once", async () => {
+            const { computeEmbeddings } = await import("./embeddings.js");
+            const index = createHybridSearchIndex(testItems, getSearchableText);
+            await index.precomputeEmbeddings();
+            await index.precomputeEmbeddings();
+            expect(computeEmbeddings).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("edge cases", () => {
+        it("should handle empty items array", async () => {
+            const index = createHybridSearchIndex([], getSearchableText);
+            const bm25Results = index.searchBM25Only("test");
+            expect(bm25Results).toHaveLength(0);
+            const hybridResults = await index.search("test");
+            expect(hybridResults).toHaveLength(0);
+        });
+        it("should handle single item", async () => {
+            const singleItem = [{ name: "test", description: "Test item" }];
+            const index = createHybridSearchIndex(singleItem, getSearchableText);
+            const results = await index.search("test");
+            expect(results.length).toBeLessThanOrEqual(1);
+        });
+    });
+    describe("score composition", () => {
+        it("should combine BM25 and semantic scores", async () => {
+            const index = createHybridSearchIndex(testItems, getSearchableText, {
+                bm25Weight: 0.4,
+                semanticWeight: 0.6,
+            });
+            const results = await index.search("compress");
+            const firstResult = results[0];
+            if (firstResult && firstResult.bm25Score > 0) {
+                // If there's a BM25 match, score should be combination
+                expect(firstResult.score).toBeGreaterThan(0);
+            }
+        });
+        it("should include matched terms from BM25", async () => {
+            const index = createHybridSearchIndex(testItems, getSearchableText);
+            const results = await index.search("compress output");
+            const compressResult = results.find((r) => r.item.name === "compress");
+            if (compressResult) {
+                expect(compressResult.matchedTerms.length).toBeGreaterThan(0);
+            }
+        });
+    });
+});

package/dist/utils/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./project-detector.js";
+export * from "./command-normalizer.js";
+export * from "./output-similarity.js";
+export * from "./content-detector.js";
+export * from "./language-detector.js";
+export * from "./error-normalizer.js";
+export * from "./signature-grouper.js";
+export * from "./log-parser.js";
+export * from "./token-counter.js";
+export * from "./bm25.js";
+export * from "./embeddings.js";
+export * from "./hybrid-search.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,12 @@
+export * from "./project-detector.js";
+export * from "./command-normalizer.js";
+export * from "./output-similarity.js";
+export * from "./content-detector.js";
+export * from "./language-detector.js";
+export * from "./error-normalizer.js";
+export * from "./signature-grouper.js";
+export * from "./log-parser.js";
+export * from "./token-counter.js";
+export * from "./bm25.js";
+export * from "./embeddings.js";
+export * from "./hybrid-search.js";