squish-memory 1.1.5 → 1.2.1

package/dist/core/adapters/types.js

@@ -1,50 +0,0 @@
-/**
- * UAM Adapter Types
- *
- * Universal Agent Memory - Adapter interfaces for different AI coding agents.
- * Each agent (Claude Code, OpenCode, Cursor, Windsurf, etc.) has its own adapter
- * that defines how to integrate with Squish.
- *
- * Key concepts:
- * - Agent adapters use native config formats where possible
- * - Hooks are explicit (calls squish_learn) not hidden
- * - Uses existing MCP tools (squish_context, squish_learn)
- */
-import { z } from 'zod';
-/** Zod schemas for validation */
-export const SessionContextInputSchema = z.object({
-    project: z.string(),
-    mode: z.enum(['startup', 'resume', 'compact']).default('startup'),
-    sessionId: z.string().optional(),
-});
-export const ToolObservationInputSchema = z.object({
-    toolName: z.string(),
-    toolInput: z.record(z.unknown()),
-    toolResult: z.unknown(),
-    project: z.string(),
-    sessionId: z.string().optional(),
-});
-export const TimelineInputSchema = z.object({
-    query: z.string(),
-    depth: z.enum(['index', 'timeline', 'detail']).default('index'),
-    limit: z.number().min(1).max(100).default(10),
-});
-/** Tool category mapping */
-export const TOOL_CATEGORIES = {
-    'Read': 'reading',
-    'Write': 'modification',
-    'Edit': 'modification',
-    'Bash': 'command',
-    'grep': 'search',
-    'Glob': 'search',
-    'TodoWrite': 'planning',
-    'TodoRead': 'planning',
-    'Task': 'planning',
-};
-/**
- * Categorize a tool call
- */
-export function categorizeTool(toolName) {
-    return TOOL_CATEGORIES[toolName] || 'other';
-}
-//# sourceMappingURL=types.js.map

package/dist/core/algorithms/analytics/token-estimator.d.ts

@@ -1,50 +0,0 @@
-/**
- * Token estimation for calculating context window savings from merges.
- * Uses simple heuristic: 1 token ≈ 4 characters (can be upgraded to tiktoken for accuracy).
- */
-import type { Memory } from '../../../db/drizzle/schema.js';
-import type { MergedMemory } from '../strategies/merge-strategies.js';
-export declare function estimateTokensSaved(sources: Memory[], merged: MergedMemory): number;
-export declare function calculateProjectTokenSavings(projectId: string): Promise<{
-    totalSaved: number;
-    mergeCount: number;
-    avgSavingsPerMerge: number;
-    tokenSavingPercentage: number;
-    totalMemoryTokens: number;
-}>;
-/**
- * Format token counts for display
- *
- * Converts token count to human-readable format with context usage
- */
-export declare function formatTokenCount(tokens: number): string;
-/**
- * Format savings report
- */
-export declare function formatSavingsReport(savings: {
-    totalSaved: number;
-    mergeCount: number;
-    avgSavingsPerMerge: number;
-    tokenSavingPercentage: number;
-    totalMemoryTokens: number;
-}): string;
-/**
- * Estimate savings for a proposed merge (preview)
- *
- * Used in merge preview to show user estimated savings
- */
-export declare function estimateMergeSavingsPreview(sources: Memory[], merged: MergedMemory): {
-    savedTokens: number;
-    savedPercentage: number;
-};
-/**
- * Get token statistics for a set of memories
- */
-export declare function getTokenStatistics(memories: Memory[]): {
-    total: number;
-    min: number;
-    max: number;
-    average: number;
-    median: number;
-};
-//# sourceMappingURL=token-estimator.d.ts.map

package/dist/core/algorithms/analytics/token-estimator.js

@@ -1,154 +0,0 @@
-/**
- * Token estimation for calculating context window savings from merges.
- * Uses simple heuristic: 1 token ≈ 4 characters (can be upgraded to tiktoken for accuracy).
- */
-import { getDb } from '../../../db/index.js';
-import { getSchema } from '../../../db/schema.js';
-import { createDatabaseClient } from '../../../core/storage/database.js';
-import { eq } from 'drizzle-orm';
-function estimateTokensSimple(text) {
-    if (!text)
-        return 0;
-    return Math.ceil(text.length / 4);
-}
-function estimateMetadataOverhead() {
-    return 25;
-}
-function estimateMemoryTokens(memory) {
-    let tokens = 0;
-    tokens += estimateTokensSimple(memory.content);
-    if (memory.summary) {
-        tokens += estimateTokensSimple(memory.summary);
-    }
-    if (memory.tags && memory.tags.length > 0) {
-        tokens += estimateTokensSimple(memory.tags.join(' '));
-    }
-    if (memory.metadata) {
-        tokens += estimateTokensSimple(JSON.stringify(memory.metadata));
-    }
-    tokens += estimateMetadataOverhead();
-    return tokens;
-}
-function estimateMergedMemoryTokens(merged) {
-    let tokens = 0;
-    tokens += estimateTokensSimple(merged.content);
-    if (merged.summary) {
-        tokens += estimateTokensSimple(merged.summary);
-    }
-    if (merged.tags && merged.tags.length > 0) {
-        tokens += estimateTokensSimple(merged.tags.join(' '));
-    }
-    tokens += estimateTokensSimple(JSON.stringify(merged.metadata));
-    tokens += estimateMetadataOverhead();
-    return tokens;
-}
-export function estimateTokensSaved(sources, merged) {
-    const sourceTokens = sources.reduce((sum, memory) => sum + estimateMemoryTokens(memory), 0);
-    const mergedTokens = estimateMergedMemoryTokens(merged);
-    const savings = sourceTokens - mergedTokens;
-    return Math.max(0, savings);
-}
-export async function calculateProjectTokenSavings(projectId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const memories = await db
-        .select()
-        .from(schema.memories)
-        .where(eq(schema.memories.projectId, projectId));
-    const totalMemoryTokens = memories.reduce((sum, m) => sum + estimateMemoryTokens(m), 0);
-    if (!schema.memoryMergeHistory) {
-        return {
-            totalSaved: 0,
-            mergeCount: 0,
-            avgSavingsPerMerge: 0,
-            tokenSavingPercentage: 0,
-            totalMemoryTokens,
-        };
-    }
-    const mergeHistory = await db
-        .select()
-        .from(schema.memoryMergeHistory)
-        .where(eq(schema.memoryMergeHistory.projectId, projectId));
-    // Sum up token savings
-    const totalSaved = mergeHistory.reduce((sum, record) => sum + (record.tokensSaved || 0), 0);
-    const mergeCount = mergeHistory.length;
-    const avgSavingsPerMerge = mergeCount > 0 ? Math.round(totalSaved / mergeCount) : 0;
-    const tokenSavingPercentage = totalMemoryTokens > 0 ? (totalSaved / totalMemoryTokens) * 100 : 0;
-    return {
-        totalSaved,
-        mergeCount,
-        avgSavingsPerMerge,
-        tokenSavingPercentage,
-        totalMemoryTokens,
-    };
-}
-/**
- * Format token counts for display
- *
- * Converts token count to human-readable format with context usage
- */
-export function formatTokenCount(tokens) {
-    // Show percentage of typical context window
-    // Claude 3 / GPT-4: 128k tokens (~32k practical for context)
-    const contextWindow = 128000;
-    const typicalUseful = 32000;
-    const percentage = (tokens / contextWindow) * 100;
-    const usefulPercent = (tokens / typicalUseful) * 100;
-    if (tokens < 1000) {
-        return `${tokens} tokens (${percentage.toFixed(3)}% of context)`;
-    }
-    const kiloTokens = (tokens / 1000).toFixed(1);
-    return `${kiloTokens}k tokens (${usefulPercent.toFixed(1)}% of typical recall window)`;
-}
-/**
- * Format savings report
- */
-export function formatSavingsReport(savings) {
-    const lines = [];
-    lines.push('Memory Merge Savings Report');
-    lines.push('='.repeat(40));
-    if (savings.mergeCount === 0) {
-        lines.push('No merges completed yet');
-        return lines.join('\n');
-    }
-    lines.push(`Total Merges: ${savings.mergeCount}`);
-    lines.push(`Total Tokens Saved: ${formatTokenCount(savings.totalSaved)}`);
-    lines.push(`Avg Savings per Merge: ${formatTokenCount(savings.avgSavingsPerMerge)}`);
-    lines.push(`Reduction: ${savings.tokenSavingPercentage.toFixed(2)}%`);
-    lines.push(`Total Memory Tokens: ${formatTokenCount(savings.totalMemoryTokens)}`);
-    return lines.join('\n');
-}
-/**
- * Estimate savings for a proposed merge (preview)
- *
- * Used in merge preview to show user estimated savings
- */
-export function estimateMergeSavingsPreview(sources, merged) {
-    const sourceTokens = sources.reduce((sum, m) => sum + estimateMemoryTokens(m), 0);
-    const mergedTokens = estimateMergedMemoryTokens(merged);
-    const savedTokens = Math.max(0, sourceTokens - mergedTokens);
-    const savedPercentage = sourceTokens > 0 ? (savedTokens / sourceTokens) * 100 : 0;
-    return { savedTokens, savedPercentage };
-}
-/**
- * Get token statistics for a set of memories
- */
-export function getTokenStatistics(memories) {
-    const counts = memories.map((m) => estimateMemoryTokens(m));
-    const total = counts.reduce((a, b) => a + b, 0);
-    const min = Math.min(...counts);
-    const max = Math.max(...counts);
-    const average = Math.round(total / counts.length);
-    // Calculate median
-    const sorted = [...counts].sort((a, b) => a - b);
-    const middle = Math.floor(sorted.length / 2);
-    const median = sorted.length % 2 !== 0 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
-    return {
-        total,
-        min,
-        max,
-        average,
-        median: Math.round(median),
-    };
-}
-//# sourceMappingURL=token-estimator.js.map

package/dist/core/algorithms/detection/hash-filters.d.ts

@@ -1,47 +0,0 @@
-/**
- * Hash-based duplicate detection filters (Stage 1).
- * Uses SimHash and MinHash for fast approximate matching before semantic analysis.
- */
-/**
- * SimHash: Fast fingerprinting for near-duplicate detection.
- * Tokenizes content, weights by frequency, and produces comparable hash fingerprints.
- * Similar documents produce similar hashes with Hamming distance indicating edit distance.
- */
-export declare class SimHashFilter {
-    private readonly dimensions;
-    generateHash(content: string): string;
-    hammingDistance(hash1: string, hash2: string): number;
-    findCandidates(targetHash: string, allHashes: Map<string, string>, threshold: number): string[];
-    private hashToken;
-    private popcount;
-}
-/**
- * MinHash: Estimates Jaccard similarity using character n-grams and multiple hash functions.
- * Keeps minimum hash for each function, resulting in comparable signatures.
- * More effective than SimHash for paraphrases. 128 functions give ~1% error margin.
- */
-export declare class MinHashFilter {
-    private readonly numPermutations;
-    private readonly ngramSize;
-    generateSignature(content: string): number[];
-    jaccardSimilarity(sig1: number[], sig2: number[]): number;
-    findCandidates(targetSig: number[], allSigs: Map<string, number[]>, threshold: number): string[];
-    private generateNgrams;
-    private hashNgramWithSeed;
-}
-export interface Stage1CandidatePair {
-    memoryId1: string;
-    memoryId2: string;
-    simhashDistance: number;
-    minhashSimilarity: number;
-    matched: 'simhash' | 'minhash' | 'both';
-}
-/**
- * Combine SimHash and MinHash filters using union approach.
- * Candidates pass if they match EITHER filter, casting wider net for stage 2 ranking.
- */
-export declare function findCandidatePairs(memories: Map<string, string>, allSimhashes: Map<string, string>, allMinhashes: Map<string, number[]>, options: {
-    simhashThreshold?: number;
-    minhashThreshold?: number;
-}): Stage1CandidatePair[];
-//# sourceMappingURL=hash-filters.d.ts.map

package/dist/core/algorithms/detection/hash-filters.js

@@ -1,190 +0,0 @@
-/**
- * Hash-based duplicate detection filters (Stage 1).
- * Uses SimHash and MinHash for fast approximate matching before semantic analysis.
- */
-/**
- * SimHash: Fast fingerprinting for near-duplicate detection.
- * Tokenizes content, weights by frequency, and produces comparable hash fingerprints.
- * Similar documents produce similar hashes with Hamming distance indicating edit distance.
- */
-export class SimHashFilter {
-    dimensions = 32; // 32-bit hash
-    generateHash(content) {
-        if (!content || content.trim().length === 0) {
-            return '0'.repeat(16);
-        }
-        const tokens = content
-            .toLowerCase()
-            .split(/\W+/)
-            .filter((token) => token.length > 0);
-        if (tokens.length === 0) {
-            return '0'.repeat(16);
-        }
-        const tokenFreq = new Map();
-        for (const token of tokens) {
-            tokenFreq.set(token, (tokenFreq.get(token) || 0) + 1);
-        }
-        const hashBits = new Array(this.dimensions).fill(0);
-        for (const [token, freq] of tokenFreq.entries()) {
-            const tokenHash = this.hashToken(token);
-            for (let i = 0; i < this.dimensions; i++) {
-                const bitSet = (tokenHash >>> i) & 1;
-                hashBits[i] += bitSet === 1 ? freq : -freq;
-            }
-        }
-        let result = 0;
-        for (let i = 0; i < this.dimensions; i++) {
-            if (hashBits[i] > 0) {
-                result |= 1 << i;
-            }
-        }
-        return (result >>> 0).toString(16).padStart(16, '0');
-    }
-    hammingDistance(hash1, hash2) {
-        const num1 = BigInt('0x' + hash1);
-        const num2 = BigInt('0x' + hash2);
-        const xor = num1 ^ num2;
-        return this.popcount(xor);
-    }
-    findCandidates(targetHash, allHashes, threshold) {
-        const candidates = [];
-        for (const [memoryId, hash] of allHashes.entries()) {
-            const distance = this.hammingDistance(targetHash, hash);
-            if (distance <= threshold) {
-                candidates.push(memoryId);
-            }
-        }
-        return candidates;
-    }
-    hashToken(token) {
-        let hash = 2166136261;
-        for (let i = 0; i < token.length; i++) {
-            hash ^= token.charCodeAt(i);
-            hash = (hash * 16777619) & 0xffffffff;
-        }
-        const high = hash >>> 16;
-        const low = hash & 0xffff;
-        return (high * 65599 + low) >>> 0;
-    }
-    popcount(n) {
-        let count = 0;
-        while (n > 0n) {
-            count += Number(n & 1n);
-            n = n >> 1n;
-        }
-        return count;
-    }
-}
-/**
- * MinHash: Estimates Jaccard similarity using character n-grams and multiple hash functions.
- * Keeps minimum hash for each function, resulting in comparable signatures.
- * More effective than SimHash for paraphrases. 128 functions give ~1% error margin.
- */
-export class MinHashFilter {
-    numPermutations = 128; // Number of independent hash functions
-    ngramSize = 3; // Character n-gram size
-    generateSignature(content) {
-        if (!content || content.trim().length === 0) {
-            return new Array(this.numPermutations).fill(0);
-        }
-        const ngrams = this.generateNgrams(content.toLowerCase(), this.ngramSize);
-        if (ngrams.length === 0) {
-            return new Array(this.numPermutations).fill(0);
-        }
-        const signature = new Array(this.numPermutations).fill(Number.MAX_SAFE_INTEGER);
-        for (const ngram of ngrams) {
-            for (let i = 0; i < this.numPermutations; i++) {
-                const hashValue = this.hashNgramWithSeed(ngram, i);
-                signature[i] = Math.min(signature[i], hashValue);
-            }
-        }
-        return signature;
-    }
-    jaccardSimilarity(sig1, sig2) {
-        if (sig1.length !== sig2.length) {
-            return 0;
-        }
-        if (sig1.length === 0) {
-            return 1;
-        }
-        let matches = 0;
-        for (let i = 0; i < sig1.length; i++) {
-            if (sig1[i] === sig2[i]) {
-                matches++;
-            }
-        }
-        return matches / sig1.length;
-    }
-    findCandidates(targetSig, allSigs, threshold) {
-        const candidates = [];
-        for (const [memoryId, sig] of allSigs.entries()) {
-            const similarity = this.jaccardSimilarity(targetSig, sig);
-            if (similarity >= threshold) {
-                candidates.push(memoryId);
-            }
-        }
-        return candidates;
-    }
-    generateNgrams(content, size) {
-        const ngrams = [];
-        const padded = ' '.repeat(size - 1) + content + ' '.repeat(size - 1);
-        for (let i = 0; i <= padded.length - size; i++) {
-            ngrams.push(padded.substring(i, i + size));
-        }
-        return ngrams;
-    }
-    hashNgramWithSeed(ngram, seed) {
-        let hash = seed;
-        for (let i = 0; i < ngram.length; i++) {
-            hash = (hash << 5) - hash + ngram.charCodeAt(i);
-            hash = hash & hash;
-        }
-        return Math.abs(hash);
-    }
-}
-/**
- * Combine SimHash and MinHash filters using union approach.
- * Candidates pass if they match EITHER filter, casting wider net for stage 2 ranking.
- */
-export function findCandidatePairs(memories, allSimhashes, allMinhashes, options) {
-    const simhashThreshold = options.simhashThreshold ?? 4;
-    const minhashThreshold = options.minhashThreshold ?? 0.7;
-    const simhashFilter = new SimHashFilter();
-    const minhashFilter = new MinHashFilter();
-    const candidatePairs = [];
-    const seen = new Set();
-    const memoryIds = Array.from(memories.keys());
-    for (let i = 0; i < memoryIds.length; i++) {
-        const id1 = memoryIds[i];
-        const simhash1 = allSimhashes.get(id1);
-        const minhash1 = allMinhashes.get(id1);
-        if (!simhash1 || !minhash1)
-            continue;
-        for (let j = i + 1; j < memoryIds.length; j++) {
-            const id2 = memoryIds[j];
-            const simhash2 = allSimhashes.get(id2);
-            const minhash2 = allMinhashes.get(id2);
-            if (!simhash2 || !minhash2)
-                continue;
-            const pairKey = id1 < id2 ? `${id1}:${id2}` : `${id2}:${id1}`;
-            if (seen.has(pairKey))
-                continue;
-            const simhashDist = simhashFilter.hammingDistance(simhash1, simhash2);
-            const simhashMatch = simhashDist <= simhashThreshold;
-            const minhashSim = minhashFilter.jaccardSimilarity(minhash1, minhash2);
-            const minhashMatch = minhashSim >= minhashThreshold;
-            if (simhashMatch || minhashMatch) {
-                seen.add(pairKey);
-                candidatePairs.push({
-                    memoryId1: id1,
-                    memoryId2: id2,
-                    simhashDistance: simhashDist,
-                    minhashSimilarity: minhashSim,
-                    matched: simhashMatch && minhashMatch ? 'both' : simhashMatch ? 'simhash' : 'minhash',
-                });
-            }
-        }
-    }
-    return candidatePairs;
-}
-//# sourceMappingURL=hash-filters.js.map

package/dist/core/algorithms/detection/semantic-ranker.d.ts

@@ -1,32 +0,0 @@
-/**
- * Semantic ranking using embeddings (Stage 2 of two-stage detection).
- * Ranks candidates from Stage 1 by semantic similarity using cosine distance.
- */
-import type { Memory } from '../../../db/drizzle/schema.js';
-export interface RankedCandidate {
-    memoryId1: string;
-    memoryId2: string;
-    memory1: Memory;
-    memory2: Memory;
-    cosineSimilarity: number;
-    confidenceLevel: 'high' | 'medium' | 'low';
-    mergeReason: string;
-}
-export declare function rankCandidates(candidates: Array<{
-    memoryId1: string;
-    memoryId2: string;
-}>, memories: Map<string, Memory>, embeddings: Map<string, number[]>, options: {
-    semanticThreshold?: number;
-    topK?: number;
-}): Promise<RankedCandidate[]>;
-export declare function analyzePair(memory1: Memory, memory2: Memory, embedding1: number[], embedding2: number[]): {
-    cosineSimilarity: number;
-    confidenceLevel: 'high' | 'medium' | 'low';
-    mergeReason: string;
-    factors: {
-        sameType: boolean;
-        tagOverlap: number;
-        contentLengthSimilarity: number;
-    };
-};
-//# sourceMappingURL=semantic-ranker.d.ts.map

package/dist/core/algorithms/detection/semantic-ranker.js

@@ -1,118 +0,0 @@
-/**
- * Semantic ranking using embeddings (Stage 2 of two-stage detection).
- * Ranks candidates from Stage 1 by semantic similarity using cosine distance.
- */
-import { cosineSimilarity } from '../../../core/utils/vector-operations.js';
-function calculateConfidence(memory1, memory2, cosineSim) {
-    if (cosineSim >= 0.90) {
-        const factors = calculateConfidenceFactors(memory1, memory2);
-        if (factors.sameType && factors.tagOverlap > 0.5) {
-            return 'high';
-        }
-        if (factors.sameType || factors.tagOverlap > 0.3) {
-            return 'high';
-        }
-        return 'medium';
-    }
-    if (cosineSim >= 0.80) {
-        const factors = calculateConfidenceFactors(memory1, memory2);
-        if (factors.sameType && factors.contentLengthSimilarity > 0.7) {
-            return 'medium';
-        }
-        return 'medium';
-    }
-    return 'low';
-}
-function calculateConfidenceFactors(memory1, memory2) {
-    const sameType = memory1.type === memory2.type;
-    const tags1 = new Set(memory1.tags || []);
-    const tags2 = new Set(memory2.tags || []);
-    const overlap = Array.from(tags1).filter((tag) => tags2.has(tag)).length;
-    const union = new Set([...tags1, ...tags2]).size;
-    const tagOverlap = union === 0 ? 0 : overlap / union;
-    const len1 = memory1.content.length;
-    const len2 = memory2.content.length;
-    const maxLen = Math.max(len1, len2);
-    const minLen = Math.min(len1, len2);
-    const contentLengthSimilarity = maxLen === 0 ? 1 : minLen / maxLen;
-    return {
-        sameType,
-        tagOverlap,
-        contentLengthSimilarity,
-    };
-}
-function generateMergeReason(memory1, memory2, cosineSim, confidenceLevel) {
-    const factors = calculateConfidenceFactors(memory1, memory2);
-    const parts = [];
-    parts.push(`Semantic similarity: ${(cosineSim * 100).toFixed(1)}%`);
-    if (factors.sameType) {
-        parts.push(`Same type (${memory1.type})`);
-    }
-    else {
-        parts.push(`Different types (${memory1.type} vs ${memory2.type})`);
-    }
-    if (factors.tagOverlap > 0) {
-        parts.push(`${(factors.tagOverlap * 100).toFixed(0)}% tag overlap`);
-    }
-    const len1 = memory1.content.length;
-    const len2 = memory2.content.length;
-    const diffPercent = Math.abs(len1 - len2) / Math.max(len1, len2);
-    parts.push(`Content length difference: ${(diffPercent * 100).toFixed(0)}%`);
-    parts.push(`Confidence: ${confidenceLevel}`);
-    return parts.join(' • ');
-}
-export async function rankCandidates(candidates, memories, embeddings, options) {
-    const semanticThreshold = options.semanticThreshold ?? 0.85;
-    const topK = options.topK ?? 10;
-    const rankedCandidates = [];
-    for (const { memoryId1, memoryId2 } of candidates) {
-        const memory1 = memories.get(memoryId1);
-        const memory2 = memories.get(memoryId2);
-        const embedding1 = embeddings.get(memoryId1);
-        const embedding2 = embeddings.get(memoryId2);
-        if (!memory1 || !memory2 || !embedding1 || !embedding2) {
-            continue;
-        }
-        const similarity = cosineSimilarity(embedding1, embedding2);
-        if (similarity < semanticThreshold) {
-            continue;
-        }
-        const confidence = calculateConfidence(memory1, memory2, similarity);
-        const mergeReason = generateMergeReason(memory1, memory2, similarity, confidence);
-        rankedCandidates.push({
-            memoryId1,
-            memoryId2,
-            memory1,
-            memory2,
-            cosineSimilarity: similarity,
-            confidenceLevel: confidence,
-            mergeReason,
-        });
-    }
-    rankedCandidates.sort((a, b) => b.cosineSimilarity - a.cosineSimilarity);
-    const selectedByMemory = new Map();
-    const filtered = [];
-    for (const candidate of rankedCandidates) {
-        const count1 = (selectedByMemory.get(candidate.memoryId1) || 0) + 1;
-        const count2 = (selectedByMemory.get(candidate.memoryId2) || 0) + 1;
-        if (count1 <= topK && count2 <= topK) {
-            filtered.push(candidate);
-            selectedByMemory.set(candidate.memoryId1, count1);
-            selectedByMemory.set(candidate.memoryId2, count2);
-        }
-    }
-    return filtered;
-}
-export function analyzePair(memory1, memory2, embedding1, embedding2) {
-    const similarity = cosineSimilarity(embedding1, embedding2);
-    const confidence = calculateConfidence(memory1, memory2, similarity);
-    const mergeReason = generateMergeReason(memory1, memory2, similarity, confidence);
-    const factors = calculateConfidenceFactors(memory1, memory2);
-    return {
-        cosineSimilarity: similarity,
-        confidenceLevel: confidence,
-        mergeReason,
-        factors,
-    };
-}
-//# sourceMappingURL=semantic-ranker.js.map