squish-memory 1.1.5 → 1.2.1

package/dist/core/memory/hybrid-scorer.js

@@ -1,284 +0,0 @@
-/** Hybrid Scorer - Multi-factor relevance scoring for memory ranking */
-import { logger } from '../../core/logger.js';
-export async function hybridScore(queryEmbedding, memories, options = {}) {
-    const weights = {
-        semantic: options.weights?.semantic ?? 0.30,
-        recency: options.weights?.recency ?? 0.20,
-        coactivation: options.weights?.coactivation ?? 0.10,
-        importance: options.weights?.importance ?? 0.15,
-        confidence: options.weights?.confidence ?? 0.15,
-        feedback: options.weights?.feedback ?? 0.10,
-    };
-    const decayDays = options.decayDays ?? 30;
-    const minSemanticScore = options.minSemanticScore ?? 0.0;
-    const scored = [];
-    const now = new Date();
-    for (const memory of memories) {
-        if (queryEmbedding && weights.semantic > 0) {
-            const semanticScore = calculateSemanticScore(queryEmbedding, memory);
-            if (semanticScore < minSemanticScore)
-                continue;
-        }
-        const components = {
-            semantic: queryEmbedding ? calculateSemanticScore(queryEmbedding, memory) : 50,
-            recency: calculateRecencyScore(memory, now, decayDays),
-            coactivation: calculateCoactivationScore(memory),
-            importance: calculateImportanceScore(memory),
-            confidence: calculateConfidenceScore(memory),
-            feedback: calculateFeedbackScore(memory),
-        };
-        const totalScore = Math.min(100, components.semantic * weights.semantic +
-            components.recency * weights.recency +
-            components.coactivation * weights.coactivation +
-            components.importance * weights.importance +
-            components.confidence * weights.confidence +
-            components.feedback * weights.feedback);
-        scored.push({
-            memoryId: memory.id,
-            memory,
-            totalScore: Math.round(totalScore * 100) / 100,
-            components: {
-                semantic: Math.round(components.semantic * 100) / 100,
-                recency: Math.round(components.recency * 100) / 100,
-                coactivation: Math.round(components.coactivation * 100) / 100,
-                importance: Math.round(components.importance * 100) / 100,
-                confidence: Math.round(components.confidence * 100) / 100,
-                feedback: Math.round(components.feedback * 100) / 100,
-            },
-            rank: 0,
-            explanation: options.includeExplanation
-                ? generateScoreExplanation(components, weights, memory)
-                : '',
-        });
-    }
-    scored.sort((a, b) => b.totalScore - a.totalScore);
-    for (let i = 0; i < scored.length; i++) {
-        scored[i].rank = i + 1;
-    }
-    return scored;
-}
-function calculateSemanticScore(queryEmbedding, memory) {
-    if (!memory.embedding || queryEmbedding.length === 0)
-        return 50;
-    try {
-        let memoryEmbedding = null;
-        if (Array.isArray(memory.embedding)) {
-            memoryEmbedding = memory.embedding;
-        }
-        else if (typeof memory.embedding === 'string') {
-            memoryEmbedding = JSON.parse(memory.embedding);
-        }
-        if (!memoryEmbedding || memoryEmbedding.length === 0)
-            return 50;
-        const cosineSimilarity = calculateCosineSimilarity(queryEmbedding, memoryEmbedding);
-        return Math.max(0, Math.min(100, (cosineSimilarity + 1) * 50));
-    }
-    catch (error) {
-        logger.error('Error calculating semantic score', error);
-        return 50;
-    }
-}
-function calculateRecencyScore(memory, now, decayDays) {
-    // Enhanced bi-temporal recency scoring: considers validity period and learning time
-    const validFromDate = memory.validFrom ? new Date(memory.validFrom) : null;
-    const validToDate = memory.validTo ? new Date(memory.validTo) : null;
-    const recordedAtDate = memory.recordedAt ? new Date(memory.recordedAt) : null;
-    const createdDate = memory.createdAt ? new Date(memory.createdAt) : null;
-    // Calculate score based on how relevant the memory is right now
-    let score = 50; // Default neutral score
-    // If we have a validity period, score based on current time's position within that period
-    if (validFromDate && validToDate) {
-        const timeInPeriod = now.getTime() - validFromDate.getTime();
-        const periodLength = validToDate.getTime() - validFromDate.getTime();
-        if (periodLength > 0) {
-            // If now is within the validity period, high score
-            if (now >= validFromDate && now <= validToDate) {
-                // Full score if right in middle, decreasing toward edges
-                const progress = timeInPeriod / periodLength;
-                const distanceFromCenter = Math.abs(0.5 - progress) * 2; // 0 at center, 1 at edges
-                score = 100 * (1 - distanceFromCenter * 0.8); // 100 at center, 40 at edges
-            }
-            else {
-                // Outside validity period - score based on how recently it expired or how far in future
-                if (now < validFromDate) {
-                    // Future validity - score based on how soon it becomes valid
-                    const daysUntilValid = (validFromDate.getTime() - now.getTime()) / (24 * 60 * 60 * 1000);
-                    score = Math.max(20, 100 - Math.min(80, daysUntilValid / decayDays * 100));
-                }
-                else {
-                    // Past validity - score based on how recently it expired
-                    const daysSinceExpired = (now.getTime() - validToDate.getTime()) / (24 * 60 * 60 * 1000);
-                    score = Math.max(10, 60 - Math.min(50, daysSinceExpired / decayDays * 100));
-                }
-            }
-        }
-    }
-    // If we only have validFrom (open-ended validity)
-    else if (validFromDate) {
-        const daysSinceValid = (now.getTime() - validFromDate.getTime()) / (24 * 60 * 60 * 1000);
-        if (now >= validFromDate) {
-            // Still valid - decay from full score over time
-            score = Math.max(30, 100 - Math.min(70, daysSinceValid / decayDays * 100));
-        }
-        else {
-            // Becomes valid in future
-            const daysUntilValid = (validFromDate.getTime() - now.getTime()) / (24 * 60 * 60 * 1000);
-            score = Math.max(20, 100 - Math.min(80, daysUntilValid / decayDays * 100));
-        }
-    }
-    // Fallback to learned/recorded time
-    else {
-        const learnedDate = recordedAtDate || createdDate;
-        if (learnedDate) {
-            const daysSinceLearned = (now.getTime() - learnedDate.getTime()) / (24 * 60 * 60 * 1000);
-            score = 100 * Math.pow(0.5, daysSinceLearned / decayDays);
-            score = Math.max(0, Math.min(100, score));
-        }
-    }
-    return Math.round(score * 10) / 10; // Return one decimal place
-}
-function calculateCoactivationScore(memory) {
-    if (!memory.coactivationScore || memory.coactivationScore === 0)
-        return 10;
-    return Math.min(100, memory.coactivationScore * 5);
-}
-function calculateImportanceScore(memory) {
-    let score = 50;
-    if (memory.tier === 'hot')
-        score += 30;
-    else if (memory.tier === 'warm')
-        score += 15;
-    if (memory.relevanceScore)
-        score += memory.relevanceScore * 0.2;
-    if (memory.isPinned)
-        score += 10;
-    if (memory.isProtected)
-        score += 10;
-    if (memory.isMergeable || memory.isMerged)
-        score -= 10;
-    return Math.max(0, Math.min(100, score));
-}
-function calculateConfidenceScore(memory) {
-    let score = 50;
-    const signals = memory.metadata?.memorySignals;
-    if (signals) {
-        if (signals.priority === 'high')
-            score += 25;
-        if (signals.explicitTriggers && signals.explicitTriggers.length > 0) {
-            score += 15 * Math.min(signals.explicitTriggers.length, 2);
-        }
-        if (signals.implicit) {
-            if (signals.implicit.decision)
-                score += 10;
-            if (signals.implicit.correction)
-                score += 15;
-            if (signals.implicit.preference)
-                score += 8;
-            if (signals.implicit.workflowRule)
-                score += 12;
-            if (signals.implicit.lesson)
-                score += 10;
-        }
-        if (signals.requiresConflictCheck)
-            score -= 5;
-    }
-    switch (memory.type) {
-        case 'decision':
-            score += 10;
-            break;
-        case 'preference':
-            score += 5;
-            break;
-        case 'fact':
-            score += 8;
-            break;
-        case 'context':
-            score += 3;
-            break;
-    }
-    if (memory.source === 'mcp')
-        score += 5;
-    if (memory.accessCount && memory.accessCount > 5) {
-        score += Math.min(10, memory.accessCount / 2);
-    }
-    return Math.max(0, Math.min(100, score));
-}
-function calculateFeedbackScore(memory) {
-    const retrievalPriority = memory.retrievalPriority ?? 50;
-    return Math.max(0, Math.min(100, retrievalPriority));
-}
-function calculateCosineSimilarity(vecA, vecB) {
-    if (vecA.length !== vecB.length)
-        return 0;
-    let dotProduct = 0;
-    let magnitudeA = 0;
-    let magnitudeB = 0;
-    for (let i = 0; i < vecA.length; i++) {
-        dotProduct += vecA[i] * vecB[i];
-        magnitudeA += vecA[i] * vecA[i];
-        magnitudeB += vecB[i] * vecB[i];
-    }
-    magnitudeA = Math.sqrt(magnitudeA);
-    magnitudeB = Math.sqrt(magnitudeB);
-    if (magnitudeA === 0 || magnitudeB === 0)
-        return 0;
-    return dotProduct / (magnitudeA * magnitudeB);
-}
-function generateScoreExplanation(components, weights, memory) {
-    const parts = [];
-    if (components.semantic > 70)
-        parts.push(`highly relevant (${components.semantic.toFixed(0)})`);
-    else if (components.semantic > 50)
-        parts.push(`somewhat relevant (${components.semantic.toFixed(0)})`);
-    else
-        parts.push(`low relevance (${components.semantic.toFixed(0)})`);
-    if (components.recency > 70)
-        parts.push('recent');
-    else if (components.recency > 30)
-        parts.push('moderately recent');
-    else
-        parts.push('older');
-    if (memory.tier === 'hot')
-        parts.push('active memory');
-    else if (memory.tier === 'warm')
-        parts.push('accessible memory');
-    else
-        parts.push('archived memory');
-    if (components.coactivation > 60)
-        parts.push('frequently associated');
-    if (components.confidence > 80)
-        parts.push('high confidence');
-    else if (components.confidence > 60)
-        parts.push('moderate confidence');
-    else if (components.confidence < 40)
-        parts.push('low confidence');
-    if (components.feedback > 70)
-        parts.push('frequently useful');
-    else if (components.feedback < 30)
-        parts.push('rarely used');
-    return parts.join(', ');
-}
-export async function scoreAndRankMemories(queryEmbedding, memories, topK = 10, options = {}) {
-    const scored = await hybridScore(queryEmbedding, memories, options);
-    logger.debug('Scored and ranked memories', {
-        total: scored.length,
-        topK,
-        topScores: scored.slice(0, topK).map((s) => ({ id: s.memoryId, score: s.totalScore })),
-    });
-    return scored.slice(0, topK);
-}
-export function getScoreDistribution(scored) {
-    if (scored.length === 0) {
-        return { min: 0, max: 0, avg: 0, median: 0, p95: 0, p99: 0 };
-    }
-    const scores = scored.map((s) => s.totalScore).sort((a, b) => a - b);
-    return {
-        min: scores[0],
-        max: scores[scores.length - 1],
-        avg: scores.reduce((a, b) => a + b, 0) / scores.length,
-        median: scores[Math.floor(scores.length / 2)],
-        p95: scores[Math.floor((95 / 100) * scores.length)],
-        p99: scores[Math.floor((99 / 100) * scores.length)],
-    };
-}
-//# sourceMappingURL=hybrid-scorer.js.map

package/dist/core/memory/hybrid-search.d.ts

@@ -1,20 +0,0 @@
-/**
- * Hybrid Search - Combines BM25 keyword search with vector semantic search
- * Uses Reciprocal Rank Fusion (RRF) for result merging
- */
-import type { SearchResult, SearchInput } from './memories.js';
-export interface HybridSearchOptions {
-    limit?: number;
-    project?: string;
-    type?: string;
-    tags?: string[];
-    /** Weight for BM25 results (0-1), default 0.5 */
-    bm25Weight?: number;
-    /** Weight for vector results (0-1), default 0.5 */
-    vectorWeight?: number;
-}
-/**
- * Main hybrid search function - combines BM25 and vector search with RRF
- */
-export declare function hybridSearch(input: SearchInput, options?: HybridSearchOptions): Promise<SearchResult[]>;
-//# sourceMappingURL=hybrid-search.d.ts.map

package/dist/core/memory/hybrid-search.js

@@ -1,359 +0,0 @@
-/**
- * Hybrid Search - Combines BM25 keyword search with vector semantic search
- * Uses Reciprocal Rank Fusion (RRF) for result merging
- */
-import { getDb } from '../../db/index.js';
-import { createDatabaseClient } from '../storage/database.js';
-import { getEmbedding } from '../../core/embeddings.js';
-import { requireProject } from '../../core/projects.js';
-import { deserializeTags, deserializeMetadata, normalizeTags } from './serialization.js';
-import { computeGraphBoost } from '../search/graph-boost.js';
-import { normalizeTimestamp } from '../lib/utils.js';
-import { cosineSimilarity } from '../utils/vector-operations.js';
-import config from '../../config.js';
-/**
- * Reciprocal Rank Fusion (RRF) constant
- * Higher values = more influence from lower-ranked items
- * 60 is the standard value used in research
- */
-const RRF_K = 60;
-/**
- * Main hybrid search function - combines BM25 and vector search with RRF
- */
-export async function hybridSearch(input, options = {}) {
-    const limit = options.limit ?? input.limit ?? 10;
-    const bm25Weight = options.bm25Weight ?? 0.5;
-    const vectorWeight = options.vectorWeight ?? 0.5;
-    // Run both searches in parallel
-    const [bm25Results, vectorResults] = await Promise.all([
-        bm25Search(input, { ...options, limit: limit * 2 }),
-        vectorSearch(input, { ...options, limit: limit * 2 }),
-    ]);
-    // Compute graph boost for the candidate memory IDs
-    const candidateIds = Array.from(new Set([...bm25Results.map(r => r.id), ...vectorResults.map(r => r.id)]));
-    const graphBoostMap = await computeGraphBoost(candidateIds);
-    // Apply RRF to merge results, incorporating graph boost
-    return reciprocalRankFusion(bm25Results, vectorResults, { limit, bm25Weight, vectorWeight }, graphBoostMap);
-}
-/**
- * BM25 keyword search using SQLite FTS5
- */
-async function bm25Search(input, options) {
-    try {
-        const db = createDatabaseClient(await getDb());
-        const sqlite = db.$client;
-        const limit = options.limit ?? 10;
-        const tags = normalizeTags(options.tags ?? input.tags);
-        // Build FTS5 query with proper escaping
-        const ftsQuery = buildFtsQuery(input.query);
-        const isEmptyQuery = ftsQuery === '*';
-        // Build WHERE conditions
-        const conditions = [];
-        const params = [];
-        // For non-empty queries, use FTS5 MATCH
-        if (!isEmptyQuery) {
-            conditions.push('memories_fts MATCH ?');
-            params.push(ftsQuery);
-        }
-        if (input.type) {
-            conditions.push('m.type = ?');
-            params.push(input.type);
-        }
-        if (tags.length) {
-            conditions.push('(' + tags.map(() => 'm.tags LIKE ?').join(' OR ') + ')');
-            params.push(...tags.map((tag) => `%${tag}%`));
-        }
-        let projectId = null;
-        if (input.project) {
-            const project = await requireProject(input.project);
-            projectId = project.id;
-            conditions.push('m.project_id = ?');
-            params.push(project.id);
-        }
-        // For empty query with no filters, use "1=1" to match all
-        const whereClause = conditions.length > 0 ? conditions.join(' AND ') : '1=1';
-        // Build query based on whether we have a search term or not
-        const statement = sqlite.prepare(`
-      SELECT
-        m.id as id,
-        m.project_id as projectId,
-        m.type as type,
-        m.content as content,
-        m.summary as summary,
-        m.tags as tags,
-        m.metadata as metadata,
-        ${isEmptyQuery ? '0 as bm25Score' : 'bm25(memories_fts) as bm25Score'},
-        m.created_at as createdAt
-      FROM memories m
-      ${isEmptyQuery ? '' : 'INNER JOIN memories_fts ON m.rowid = memories_fts.rowid'}
-      WHERE ${whereClause}
-      ${isEmptyQuery ? 'ORDER BY m.created_at DESC' : 'ORDER BY bm25(memories_fts)'}
-      LIMIT ?
-    `);
-        const rows = statement.all(...params, limit * 3);
-        // Return as ranked results (lower BM25 score = better rank)
-        return rows.map((row, index) => ({
-            id: row.id,
-            rank: index + 1,
-            score: row.bm25Score,
-            result: {
-                id: row.id,
-                projectId: row.projectId,
-                type: row.type,
-                content: row.content,
-                summary: row.summary ?? undefined,
-                tags: deserializeTags(row.tags ?? null),
-                metadata: deserializeMetadata(row.metadata ?? null),
-                createdAt: row.createdAt ? (normalizeTimestamp(Number(row.createdAt)) ?? undefined) : undefined,
-            },
-        }));
-    }
-    catch (error) {
-        throw error;
-    }
-}
-/**
- * Vector semantic search using cosine similarity
- */
-async function vectorSearch(input, options) {
-    try {
-        const db = createDatabaseClient(await getDb());
-        const sqlite = db.$client;
-        const limit = options.limit ?? 10;
-        const tags = normalizeTags(options.tags ?? input.tags);
-        // Check for empty query
-        const isEmptyQuery = !input.query || input.query.trim() === '';
-        // Get query embedding (only for non-empty queries)
-        let queryEmbedding = null;
-        if (!isEmptyQuery) {
-            queryEmbedding = await getEmbedding(input.query);
-            // If embedding fails but query is not empty, still proceed without semantic ranking
-            // Fall back to recency-based ranking
-        }
-        // Build WHERE conditions
-        const conditions = [];
-        const params = [];
-        if (input.type) {
-            conditions.push('m.type = ?');
-            params.push(input.type);
-        }
-        if (tags.length) {
-            conditions.push('(' + tags.map(() => 'm.tags LIKE ?').join(' OR ') + ')');
-            params.push(...tags.map((tag) => `%${tag}%`));
-        }
-        let projectId = null;
-        if (input.project) {
-            const project = await requireProject(input.project);
-            projectId = project.id;
-            conditions.push('m.project_id = ?');
-            params.push(project.id);
-        }
-        const whereClause = conditions.length > 0
-            ? 'WHERE ' + conditions.join(' AND ')
-            : '';
-        // Fetch candidates for vector search
-        const statement = sqlite.prepare(`
-      SELECT
-        m.id as id,
-        m.project_id as projectId,
-        m.type as type,
-        m.content as content,
-        m.summary as summary,
-        m.tags as tags,
-        m.metadata as metadata,
-        m.embedding as embedding,
-        m.embedding_json as embeddingJson,
-        m.created_at as createdAt
-      FROM memories m
-      ${whereClause}
-      ORDER BY m.created_at DESC
-      LIMIT ?
-    `);
-        const rows = statement.all(...params, limit * 3);
-        // If no embedding available, return results ordered by recency
-        if (!queryEmbedding) {
-            return rows.slice(0, limit * 2).map((item, index) => ({
-                id: item.id,
-                rank: index + 1,
-                score: 0, // No similarity score available
-                result: {
-                    id: item.id,
-                    projectId: item.projectId,
-                    type: item.type,
-                    content: item.content,
-                    summary: item.summary ?? undefined,
-                    tags: deserializeTags(item.tags ?? null),
-                    metadata: deserializeMetadata(item.metadata ?? null),
-                    createdAt: item.createdAt ? (normalizeTimestamp(Number(item.createdAt)) ?? undefined) : undefined,
-                    similarity: 0,
-                },
-            }));
-        }
-        // Calculate cosine similarity for each result
-        const scored = rows
-            .map((row) => {
-            const embedding = parseEmbedding(row.embedding) ?? parseEmbedding(row.embeddingJson);
-            if (!embedding)
-                return null;
-            const similarity = cosineSimilarity(queryEmbedding, embedding);
-            return {
-                id: row.id,
-                projectId: row.projectId,
-                type: row.type,
-                content: row.content,
-                summary: row.summary,
-                tags: row.tags,
-                metadata: row.metadata,
-                createdAt: row.createdAt,
-                similarity,
-            };
-        })
-            .filter((item) => item !== null);
-        // Sort by similarity (descending) and return as ranked results
-        scored.sort((a, b) => b.similarity - a.similarity);
-        return scored.slice(0, limit * 2).map((item, index) => ({
-            id: item.id,
-            rank: index + 1,
-            score: item.similarity,
-            result: {
-                id: item.id,
-                projectId: item.projectId,
-                type: item.type,
-                content: item.content,
-                summary: item.summary ?? undefined,
-                tags: deserializeTags(item.tags ?? null),
-                metadata: deserializeMetadata(item.metadata ?? null),
-                createdAt: item.createdAt ? (normalizeTimestamp(Number(item.createdAt)) ?? undefined) : undefined,
-                similarity: item.similarity,
-            },
-        }));
-    }
-    catch (error) {
-        throw error;
-    }
-}
-/**
- * Reciprocal Rank Fusion (RRF) - merges ranked lists without score calibration
- *
- * RRF Formula: score(item) = sum(weight_i / (k + rank_i))
- * Where k is a constant (typically 60) that prevents high ranks from dominating
- *
- * Benefits:
- * - No need to calibrate different scoring systems (BM25 vs cosine similarity)
- * - Handles items that appear in only one list
- * - Proven to outperform weighted score fusion in most cases
- */
-function reciprocalRankFusion(bm25Results, vectorResults, options, graphBoostMap) {
-    const { limit, bm25Weight, vectorWeight } = options;
-    const scores = new Map();
-    // Process BM25 results
-    for (const item of bm25Results) {
-        const rrfScore = (bm25Weight * 2) / (RRF_K + item.rank);
-        const existing = scores.get(item.id);
-        if (existing) {
-            existing.score += rrfScore;
-        }
-        else {
-            scores.set(item.id, { score: rrfScore, result: item.result });
-        }
-    }
-    // Process vector results
-    for (const item of vectorResults) {
-        const rrfScore = (vectorWeight * 2) / (RRF_K + item.rank);
-        const existing = scores.get(item.id);
-        if (existing) {
-            existing.score += rrfScore;
-        }
-        else {
-            scores.set(item.id, { score: rrfScore, result: item.result });
-        }
-    }
-    // Add graph boost to each score
-    for (const [id, entry] of scores.entries()) {
-        const boost = graphBoostMap[id] ?? 0;
-        const weight = config.scoringWeights.graphBoost ?? 1;
-        entry.score += boost * weight;
-    }
-    // Sort by final score (descending) and return top results
-    return Array.from(scores.values())
-        .sort((a, b) => b.score - a.score)
-        .slice(0, limit)
-        .map((item) => ({
-        ...item.result,
-        similarity: item.result.similarity ?? 0,
-    }));
-}
-/**
- * Build FTS5 query string from user input
- * Handles phrase searches, OR operators for better recall, and special characters
- */
-function buildFtsQuery(query) {
-    // Ensure query is a string
-    const queryString = typeof query === 'string' ? query : String(query ?? '');
-    // Remove special characters that could break FTS5 syntax (except quotes)
-    // Hyphens are problematic in FTS5 - they're treated as exclusion operators
-    let cleaned = queryString.replace(/[^\w\s"'-]/g, ' ');
-    // If query contains quotes, preserve as phrase search
-    if (cleaned.includes('"')) {
-        return cleaned || '*'; // Return * for empty after cleaning
-    }
-    // Split into terms
-    const terms = cleaned.trim().split(/\s+/).filter((t) => t.length > 0);
-    if (terms.length === 0) {
-        return '*'; // Match all for empty query
-    }
-    // Wrap terms containing hyphens in quotes (e.g., "trash-cli" prevents hyphen being interpreted as NOT)
-    const processedTerms = terms.map(term => {
-        if (term.includes('-')) {
-            return `"${term}"`;
-        }
-        return term;
-    });
-    // For multi-word queries, use OR for better recall (any term matches)
-    // This is less restrictive than AND and finds more relevant results
-    if (processedTerms.length > 1) {
-        return processedTerms.join(' OR ');
-    }
-    return processedTerms[0];
-}
-/**
- * Parse embedding from SQLite storage
- */
-function parseEmbedding(embeddingData) {
-    if (!embeddingData)
-        return null;
-    if (Array.isArray(embeddingData))
-        return embeddingData;
-    if (embeddingData instanceof Uint8Array || Buffer.isBuffer(embeddingData)) {
-        try {
-            const json = JSON.parse(embeddingData.toString());
-            if (Array.isArray(json))
-                return json;
-        }
-        catch {
-            try {
-                const buffer = embeddingData.buffer;
-                const arrayBuffer = buffer instanceof ArrayBuffer
-                    ? buffer
-                    : buffer;
-                const floatArray = new Float32Array(arrayBuffer);
-                return Array.from(floatArray);
-            }
-            catch {
-                return null;
-            }
-        }
-    }
-    if (typeof embeddingData === 'string') {
-        try {
-            const parsed = JSON.parse(embeddingData);
-            if (Array.isArray(parsed))
-                return parsed;
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-}
-//# sourceMappingURL=hybrid-search.js.map