bigtool-ts 0.1.0

package/dist/search/normalize.js

@@ -0,0 +1,211 @@
+/**
+ * Score Normalization Utilities
+ *
+ * Different search algorithms produce scores in different ranges:
+ * - BM25: 0 to ~25+ (unbounded, depends on corpus)
+ * - Cosine similarity: -1 to 1 (for vectors)
+ * - Orama vector search: 0 to 1 (already normalized)
+ *
+ * We normalize everything to 0-1 for consistent thresholding.
+ */
+// ═══════════════════════════════════════════════════════════════════════════
+// BM25 Score Normalization
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Normalize BM25 scores to 0-1 range.
+ *
+ * Uses min-max normalization within the result set.
+ * If all scores are the same, returns 1.0 for all.
+ *
+ * @param scores - Array of raw BM25 scores
+ * @returns Array of normalized scores (0-1)
+ */
+export function normalizeBM25Scores(scores) {
+    if (scores.length === 0)
+        return [];
+    if (scores.length === 1)
+        return [1.0];
+    const min = Math.min(...scores);
+    const max = Math.max(...scores);
+    const range = max - min;
+    if (range === 0) {
+        // All scores are the same
+        return scores.map(() => 1.0);
+    }
+    return scores.map((score) => (score - min) / range);
+}
+/**
+ * Normalize a single BM25 score using a sigmoid function.
+ * This is useful when you don't have the full result set.
+ *
+ * The sigmoid maps scores to (0, 1):
+ * - Low scores (~0-2) map to ~0.0-0.5
+ * - Medium scores (~2-10) map to ~0.5-0.9
+ * - High scores (~10+) map to ~0.9-1.0
+ *
+ * @param score - Raw BM25 score
+ * @param k - Steepness parameter (default: 5)
+ * @returns Normalized score (0-1)
+ */
+export function normalizeBM25Sigmoid(score, k = 5) {
+    // Sigmoid: 1 / (1 + e^(-x/k))
+    // Shifted so that 0 input gives ~0.5 output
+    return 1 / (1 + Math.exp(-score / k));
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Vector Similarity Normalization
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Normalize cosine similarity from [-1, 1] to [0, 1]
+ *
+ * @param similarity - Cosine similarity value (-1 to 1)
+ * @returns Normalized score (0-1)
+ */
+export function normalizeCosineSimilarity(similarity) {
+    // Map [-1, 1] to [0, 1]
+    return (similarity + 1) / 2;
+}
+/**
+ * Orama already returns vector scores in 0-1 range (distance-based).
+ * This function clamps to ensure valid range.
+ *
+ * @param score - Orama vector search score
+ * @returns Clamped score (0-1)
+ */
+export function normalizeOramaVectorScore(score) {
+    return Math.max(0, Math.min(1, score));
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Hybrid Score Combination
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Combine BM25 and vector scores using weighted average.
+ *
+ * @param bm25Score - Normalized BM25 score (0-1)
+ * @param vectorScore - Normalized vector score (0-1)
+ * @param weights - Weight configuration
+ * @returns Combined score (0-1)
+ */
+export function combineScores(bm25Score, vectorScore, weights) {
+    const total = weights.bm25 + weights.vector;
+    return (bm25Score * weights.bm25 + vectorScore * weights.vector) / total;
+}
+/**
+ * Reciprocal Rank Fusion (RRF) for combining ranked lists.
+ *
+ * RRF is a rank-based fusion method that doesn't require score normalization.
+ * It's useful when BM25 and vector scores are not directly comparable.
+ *
+ * Formula: score = sum(1 / (k + rank)) for each list the item appears in
+ *
+ * @param bm25Rank - Rank in BM25 results (1-indexed, null if not present)
+ * @param vectorRank - Rank in vector results (1-indexed, null if not present)
+ * @param k - Smoothing constant (default: 60, standard value)
+ * @returns RRF score (higher is better)
+ */
+export function reciprocalRankFusion(bm25Rank, vectorRank, k = 60) {
+    let score = 0;
+    if (bm25Rank !== null) {
+        score += 1 / (k + bm25Rank);
+    }
+    if (vectorRank !== null) {
+        score += 1 / (k + vectorRank);
+    }
+    return score;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Result Merging
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Merge BM25 and vector results using weighted combination.
+ *
+ * Tools that appear in both result sets get combined scores.
+ * Tools that appear in only one set get their score weighted by that mode's weight.
+ *
+ * @param bm25Results - BM25 search results (normalized scores)
+ * @param vectorResults - Vector search results (normalized scores)
+ * @param weights - Weight configuration for combining
+ * @returns Merged and re-ranked results
+ */
+export function mergeHybridResults(bm25Results, vectorResults, weights) {
+    const scoreMap = new Map();
+    // Add BM25 scores
+    for (const result of bm25Results) {
+        scoreMap.set(result.toolId, {
+            bm25: result.score,
+            vector: 0,
+        });
+    }
+    // Add/merge vector scores
+    for (const result of vectorResults) {
+        const existing = scoreMap.get(result.toolId);
+        if (existing) {
+            existing.vector = result.score;
+        }
+        else {
+            scoreMap.set(result.toolId, {
+                bm25: 0,
+                vector: result.score,
+            });
+        }
+    }
+    // Combine scores and create results
+    const results = [];
+    for (const [toolId, scores] of scoreMap) {
+        const combinedScore = combineScores(scores.bm25, scores.vector, weights);
+        results.push({
+            toolId,
+            score: combinedScore,
+            matchType: "hybrid",
+        });
+    }
+    // Sort by score descending
+    results.sort((a, b) => b.score - a.score);
+    return results;
+}
+/**
+ * Merge results using Reciprocal Rank Fusion.
+ *
+ * This method is rank-based rather than score-based,
+ * which can be more robust when score distributions differ significantly.
+ *
+ * @param bm25Results - BM25 search results (order matters, not scores)
+ * @param vectorResults - Vector search results (order matters, not scores)
+ * @param k - RRF smoothing constant
+ * @returns Merged and re-ranked results
+ */
+export function mergeWithRRF(bm25Results, vectorResults, k = 60) {
+    // Create rank maps (1-indexed)
+    const bm25Ranks = new Map();
+    bm25Results.forEach((r, i) => bm25Ranks.set(r.toolId, i + 1));
+    const vectorRanks = new Map();
+    vectorResults.forEach((r, i) => vectorRanks.set(r.toolId, i + 1));
+    // Get all unique tool IDs
+    const allToolIds = new Set([
+        ...bm25Results.map((r) => r.toolId),
+        ...vectorResults.map((r) => r.toolId),
+    ]);
+    // Compute RRF scores
+    const results = [];
+    for (const toolId of allToolIds) {
+        const bm25Rank = bm25Ranks.get(toolId) ?? null;
+        const vectorRank = vectorRanks.get(toolId) ?? null;
+        const score = reciprocalRankFusion(bm25Rank, vectorRank, k);
+        results.push({
+            toolId,
+            score,
+            matchType: "hybrid",
+        });
+    }
+    // Sort by RRF score descending
+    results.sort((a, b) => b.score - a.score);
+    // Normalize RRF scores to 0-1 for consistent thresholding
+    if (results.length > 0) {
+        const maxScore = results[0].score;
+        for (const result of results) {
+            result.score = result.score / maxScore;
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=normalize.js.map

package/dist/search/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.js","sourceRoot":"","sources":["../../src/search/normalize.ts"],"names":[],"mappings":"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"}

package/dist/search/orama.d.ts

@@ -0,0 +1,256 @@
+/**
+ * OramaSearch module.
+ *
+ * Provides a powerful search index implementation using @orama/orama,
+ * supporting BM25 text search, vector semantic search, and hybrid modes.
+ *
+ * @module search/orama
+ */
+import type { SearchIndex, SearchOptions, SearchResult } from '../types/index.js';
+import type { ToolMetadata, OramaSearchConfig, Embeddings, EmbeddingCache } from "./types.js";
+/**
+ * Search index implementation using @orama/orama.
+ *
+ * OramaSearch provides fast, in-memory search for tool discovery.
+ * It supports three search modes:
+ *
+ * - **BM25**: Fast text search using TF-IDF/BM25 algorithm. No API keys
+ *   needed. Best for keyword-based queries.
+ *
+ * - **Vector**: Semantic search using embeddings. Requires an embeddings
+ *   provider (e.g., OpenAIEmbeddings). Best for natural language queries.
+ *
+ * - **Hybrid**: Combines BM25 and vector scores for best results. Uses
+ *   weighted combination with configurable weights.
+ *
+ * @example BM25 Mode (default, no API keys needed)
+ * ```typescript
+ * import { OramaSearch } from '@repo/bigtool-ts';
+ *
+ * const search = new OramaSearch({ mode: 'bm25' });
+ * await search.index(catalog.getAllMetadata());
+ *
+ * const results = await search.search('github pull request');
+ * console.log(results[0].toolId); // 'github:create_pr'
+ * ```
+ *
+ * @example Vector Mode (semantic search)
+ * ```typescript
+ * import { OramaSearch } from '@repo/bigtool-ts';
+ * import { OpenAIEmbeddings } from '@langchain/openai';
+ *
+ * const search = new OramaSearch({
+ *   mode: 'vector',
+ *   embeddings: new OpenAIEmbeddings(),
+ *   cache: new MemoryEmbeddingCache(),
+ * });
+ *
+ * await search.index(tools);
+ * const results = await search.search('help me merge code changes');
+ * ```
+ *
+ * @example Hybrid Mode (best of both)
+ * ```typescript
+ * const search = new OramaSearch({
+ *   mode: 'hybrid',
+ *   embeddings: new OpenAIEmbeddings(),
+ *   weights: { bm25: 0.4, vector: 0.6 },
+ *   boost: { name: 3, keywords: 2 },
+ * });
+ * ```
+ */
+export declare class OramaSearch implements SearchIndex {
+    /** @internal BM25 database */
+    private db;
+    /** @internal Vector database */
+    private vectorDb;
+    /** @internal Resolved configuration */
+    private config;
+    /** @internal Indexed tools for reindexing */
+    private tools;
+    /** @internal Embeddings provider */
+    private embeddings?;
+    /** @internal Embedding cache */
+    private cache?;
+    /** @internal Whether index() has been called */
+    private initialized;
+    /**
+     * Creates a new OramaSearch instance.
+     *
+     * @param config - Search configuration (mode, embeddings, etc.)
+     * @throws Error if vector/hybrid mode is used without embeddings
+     *
+     * @example
+     * ```typescript
+     * // BM25 (default)
+     * const search = new OramaSearch();
+     *
+     * // Explicit mode
+     * const search = new OramaSearch({ mode: 'bm25' });
+     *
+     * // With custom boosts
+     * const search = new OramaSearch({
+     *   mode: 'bm25',
+     *   boost: { name: 3, keywords: 2, description: 1, categories: 1 },
+     * });
+     * ```
+     */
+    constructor(config?: OramaSearchConfig);
+    /**
+     * Index a collection of tools for search.
+     *
+     * This creates the search index from the provided tool metadata.
+     * Call this after registering sources with the catalog.
+     * Replaces any existing index.
+     *
+     * For vector/hybrid modes, this also computes and caches embeddings.
+     *
+     * @param tools - Array of tool metadata to index
+     *
+     * @example
+     * ```typescript
+     * const search = new OramaSearch({ mode: 'bm25' });
+     * await search.index(catalog.getAllMetadata());
+     * ```
+     */
+    index(tools: ToolMetadata[]): Promise<void>;
+    /**
+     * Search for tools matching a query.
+     *
+     * Uses the configured search mode (BM25, vector, or hybrid).
+     * Results are normalized to 0-1 scores and sorted by relevance.
+     *
+     * @param query - Natural language search query
+     * @param options - Search options (limit, threshold, categories)
+     * @returns Array of search results sorted by relevance
+     * @throws Error if index() has not been called
+     *
+     * @example
+     * ```typescript
+     * const results = await search.search('create github pull request', {
+     *   limit: 10,
+     *   threshold: 0.3,
+     * });
+     *
+     * for (const result of results) {
+     *   console.log(`${result.toolId}: ${result.score.toFixed(2)}`);
+     * }
+     * ```
+     */
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Rebuild the index from currently indexed tools.
+     *
+     * Call this when the catalog changes (tools added/removed).
+     * Uses the tools from the last index() call.
+     *
+     * @throws Error if index() has not been called
+     *
+     * @example
+     * ```typescript
+     * // Listen for catalog changes
+     * catalog.onToolsChanged.subscribe(async () => {
+     *   await search.reindex();
+     * });
+     * ```
+     */
+    reindex(): Promise<void>;
+    /**
+     * Get the number of indexed tools.
+     *
+     * @returns Number of tools in the index
+     *
+     * @example
+     * ```typescript
+     * const indexed = await search.count();
+     * console.log(`${indexed} tools indexed`);
+     * ```
+     */
+    count(): Promise<number>;
+    private searchBM25;
+    private searchVector;
+    private searchHybrid;
+    /**
+     * Compute embeddings for tools, using cache when available.
+     */
+    private computeEmbeddings;
+}
+/**
+ * Create a BM25-only search index.
+ *
+ * This is the simplest and fastest option, requiring no API keys.
+ * Uses TF-IDF/BM25 algorithm for text matching.
+ *
+ * @param options - Optional configuration for field boosting
+ * @returns Configured OramaSearch instance
+ *
+ * @example
+ * ```typescript
+ * import { createBM25Search } from '@repo/bigtool-ts';
+ *
+ * const search = createBM25Search();
+ * await search.index(tools);
+ * ```
+ *
+ * @example With custom boosts
+ * ```typescript
+ * const search = createBM25Search({
+ *   boost: { name: 3, keywords: 2, description: 1, categories: 1 },
+ * });
+ * ```
+ */
+export declare function createBM25Search(options?: Pick<OramaSearchConfig, "boost">): OramaSearch;
+/**
+ * Create a vector search index.
+ *
+ * Uses semantic similarity via embeddings. Requires an embeddings
+ * provider (e.g., OpenAIEmbeddings).
+ *
+ * @param embeddings - Embeddings provider for computing vectors
+ * @param cache - Optional cache for storing computed embeddings
+ * @param vectorSize - Embedding dimension (default: 1536 for OpenAI)
+ * @returns Configured OramaSearch instance
+ *
+ * @example
+ * ```typescript
+ * import { createVectorSearch } from '@repo/bigtool-ts';
+ * import { OpenAIEmbeddings } from '@langchain/openai';
+ *
+ * const search = createVectorSearch(
+ *   new OpenAIEmbeddings(),
+ *   new MemoryEmbeddingCache(),
+ * );
+ * ```
+ */
+export declare function createVectorSearch(embeddings: Embeddings, cache?: EmbeddingCache, vectorSize?: number): OramaSearch;
+/**
+ * Create a hybrid search index.
+ *
+ * Combines BM25 text matching with vector semantic similarity
+ * for the best results. Uses weighted scoring to merge results.
+ *
+ * @param embeddings - Embeddings provider for computing vectors
+ * @param options - Configuration options
+ * @returns Configured OramaSearch instance
+ *
+ * @example
+ * ```typescript
+ * import { createHybridSearch } from '@repo/bigtool-ts';
+ * import { OpenAIEmbeddings } from '@langchain/openai';
+ *
+ * const search = createHybridSearch(new OpenAIEmbeddings(), {
+ *   weights: { bm25: 0.3, vector: 0.7 },
+ *   cache: new MemoryEmbeddingCache(),
+ * });
+ * ```
+ */
+export declare function createHybridSearch(embeddings: Embeddings, options?: {
+    cache?: EmbeddingCache;
+    weights?: {
+        bm25: number;
+        vector: number;
+    };
+    boost?: OramaSearchConfig["boost"];
+    vectorSize?: number;
+}): OramaSearch;
+//# sourceMappingURL=orama.d.ts.map

package/dist/search/orama.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orama.d.ts","sourceRoot":"","sources":["../../src/search/orama.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAClF,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,UAAU,EACV,cAAc,EAEf,MAAM,YAAY,CAAC;AAgEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,qBAAa,WAAY,YAAW,WAAW;IAC7C,8BAA8B;IAC9B,OAAO,CAAC,EAAE,CAA0C;IAEpD,gCAAgC;IAChC,OAAO,CAAC,QAAQ,CAA2B;IAE3C,uCAAuC;IACvC,OAAO,CAAC,MAAM,CAA8G;IAE5H,6CAA6C;IAC7C,OAAO,CAAC,KAAK,CAAsB;IAEnC,oCAAoC;IACpC,OAAO,CAAC,UAAU,CAAC,CAAa;IAEhC,gCAAgC;IAChC,OAAO,CAAC,KAAK,CAAC,CAAiB;IAE/B,gDAAgD;IAChD,OAAO,CAAC,WAAW,CAAS;IAE5B;;;;;;;;;;;;;;;;;;;;OAoBG;gBACS,MAAM,GAAE,iBAAoC;IAmCxD;;;;;;;;;;;;;;;;OAgBG;IACG,KAAK,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA4CjD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAkC7E;;;;;;;;;;;;;;;OAeG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAO9B;;;;;;;;;;OAUG;IACG,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;YAShB,UAAU;YA+BV,YAAY;YA4BZ,YAAY;IAqB1B;;OAEG;YACW,iBAAiB;CAyChC;AAMD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,GACzC,WAAW,CAKb;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,KAAK,CAAC,EAAE,cAAc,EACtB,UAAU,CAAC,EAAE,MAAM,GAClB,WAAW,CAOb;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE;IACR,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,KAAK,CAAC,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GACA,WAAW,CASb"}