squish-memory 1.2.0 → 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.string(), 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/agent-preferences.d.ts

@@ -1,16 +0,0 @@
-/**
- * Agent Preferences - Accumulate and retrieve agent preferences from learnings
- * Enables agents to learn and evolve over time
- */
-/**
- * Update agent preference from a learning
- */
-export declare function updateAgentPreference(projectId: string, content: string, sourceMemoryId?: string): Promise<void>;
-/**
- * Get all agent preferences for a project
- */
-export declare function getAgentPreferences(projectId: string): Promise<Array<{
-    key: string;
-    value: string;
-}>>;
-//# sourceMappingURL=agent-preferences.d.ts.map

package/dist/core/agent-preferences.js

@@ -1,124 +0,0 @@
-/**
- * Agent Preferences - Accumulate and retrieve agent preferences from learnings
- * Enables agents to learn and evolve over time
- */
-import { getDb } from '../db/index.js';
-import { eq, and } from 'drizzle-orm';
-import { logger } from './logger.js';
-/**
- * Extract preference from learning content
- * E.g., "Prefer bun over npm" -> key: "prefer_bun", value: "bun"
- */
-function extractPreference(content) {
-    const patterns = [
-        // "Prefer X over Y"
-        /prefer\s+(\w+)\s+over\s+(\w+)/i,
-        // "Always use X"
-        /always\s+use\s+(\w+)/i,
-        // "Use X instead of Y"
-        /use\s+(\w+)\s+instead\s+of\s+(\w+)/i,
-        // "X is better than Y"
-        /(\w+)\s+is\s+better\s+than\s+(\w+)/i,
-        // "Don't use X"
-        /(?:don't|do not|never)\s+use\s+(\w+)/i,
-    ];
-    for (const pattern of patterns) {
-        const match = content.match(pattern);
-        if (match) {
-            const key = `prefer_${match[1].toLowerCase()}`;
-            const value = match[2]?.toLowerCase() || 'true';
-            return { key, value };
-        }
-    }
-    return null;
-}
-/**
- * Update agent preference from a learning
- */
-export async function updateAgentPreference(projectId, content, sourceMemoryId) {
-    const preference = extractPreference(content);
-    if (!preference)
-        return;
-    try {
-        const db = getDb();
-        // Check if preference exists
-        const existing = await db.query.agentPreferences?.findFirst(and(eq(db.schema.agentPreferences.projectId, projectId), eq(db.schema.agentPreferences.key, preference.key))).catch(() => null);
-        if (existing) {
-            // Update existing preference
-            await db.update(db.schema.agentPreferences)
-                .set({
-                value: preference.value,
-                sourceMemoryId: sourceMemoryId,
-                usageCount: (existing.usageCount ?? 0) + 1,
-                lastUpdated: Math.floor(Date.now() / 1000)
-            })
-                .where(eq(db.schema.agentPreferences.id, existing.id))
-                .catch(() => {
-                // Fallback for SQLite which uses different table name
-                const sqlite = db._?.sqlite || db;
-                if (sqlite) {
-                    sqlite.prepare(`
-              UPDATE agent_preferences 
-              SET value = ?, source_memory_id = ?, usage_count = usage_count + 1, last_updated = ?
-              WHERE project_id = ? AND key = ?
-            `).run(preference.value, sourceMemoryId, Math.floor(Date.now() / 1000), projectId, preference.key);
-                }
-            });
-            logger.info(`[AgentPrefs] Updated preference: ${preference.key} = ${preference.value}`);
-        }
-        else {
-            // Insert new preference
-            const id = `pref_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-            await db.insert(db.schema.agentPreferences)
-                .values({
-                id,
-                projectId,
-                key: preference.key,
-                value: preference.value,
-                sourceMemoryId: sourceMemoryId ?? null,
-                confidence: 0.5,
-                usageCount: 1
-            })
-                .catch(() => {
-                // Fallback for SQLite
-                const sqlite = db._?.sqlite || db;
-                if (sqlite) {
-                    sqlite.prepare(`
-              INSERT INTO agent_preferences (id, project_id, key, value, source_memory_id, confidence, usage_count)
-              VALUES (?, ?, ?, ?, ?, 0.5, 1)
-            `).run(id, projectId, preference.key, preference.value, sourceMemoryId ?? null);
-                }
-            });
-            logger.info(`[AgentPrefs] Created preference: ${preference.key} = ${preference.value}`);
-        }
-    }
-    catch (error) {
-        logger.warn(`[AgentPrefs] Failed to update preference:`, error);
-    }
-}
-/**
- * Get all agent preferences for a project
- */
-export async function getAgentPreferences(projectId) {
-    try {
-        const db = getDb();
-        const results = await db.query.agentPreferences?.findMany({
-            where: eq(db.schema.agentPreferences.projectId, projectId)
-        }).catch(() => []);
-        if (results && results.length > 0) {
-            return results.map(p => ({ key: p.key, value: p.value }));
-        }
-        // Fallback for SQLite
-        const sqlite = db._?.sqlite || db;
-        if (sqlite) {
-            const rows = sqlite.prepare('SELECT key, value FROM agent_preferences WHERE project_id = ?').all(projectId);
-            return rows.map(r => ({ key: r.key, value: r.value }));
-        }
-        return [];
-    }
-    catch (error) {
-        logger.warn(`[AgentPrefs] Failed to get preferences:`, error);
-        return [];
-    }
-}
-//# sourceMappingURL=agent-preferences.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