memento-mcp-server 1.13.1-a0 → 1.13.1-a3

package/dist/services/anchor/anchor-search-service.js

@@ -1,918 +0,0 @@
-/**
- * Anchor Search Service
- * 검색 관련 로직 담당
- * Phase 1.1: anchor-manager.ts 리팩토링
- */
-import { UnifiedEmbeddingService } from '../unified-embedding-service.js';
-import { logger } from '../../utils/logger.js';
-import { RelationGraph } from '../relation-graph.js';
-/**
- * Anchor Search Service 구현
- */
-export class AnchorSearchService {
-    db = null;
-    cacheService;
-    hybridSearchEngine = null;
-    vectorSearchEngine = null;
-    queryEmbeddingService = new UnifiedEmbeddingService();
-    relationGraph = null;
-    /**
-     * 생성자
-     */
-    constructor(cacheService) {
-        this.cacheService = cacheService;
-        logger.info('AnchorSearchService 초기화 완료');
-    }
-    /**
-     * RelationGraph 설정 (선택적)
-     */
-    setRelationGraph(relationGraph) {
-        this.relationGraph = relationGraph;
-    }
-    /**
-     * 데이터베이스 설정
-     */
-    setDatabase(db) {
-        if (!db) {
-            throw new Error('Database instance is required');
-        }
-        this.db = db;
-    }
-    /**
-     * 하이브리드 검색 엔진 설정
-     */
-    setHybridSearchEngine(hybridSearchEngine) {
-        if (!hybridSearchEngine) {
-            throw new Error('HybridSearchEngine is required');
-        }
-        this.hybridSearchEngine = hybridSearchEngine;
-    }
-    /**
-     * 벡터 검색 엔진 설정
-     */
-    setVectorSearchEngine(vectorSearchEngine) {
-        if (!vectorSearchEngine) {
-            throw new Error('VectorSearchEngine is required');
-        }
-        this.vectorSearchEngine = vectorSearchEngine;
-        // 데이터베이스가 이미 설정되어 있으면 초기화
-        if (this.db) {
-            this.vectorSearchEngine.initialize(this.db);
-        }
-    }
-    /**
-     * 국소 검색
-     * 앵커 메모리를 기준으로 N-hop 제한 검색 수행
-     */
-    async searchLocal(agentId, slot, query, hopLimit, options, anchorMemoryId, anchorEmbedding, startTime) {
-        if (!this.db) {
-            throw new Error('Database is not set. Call setDatabase() first.');
-        }
-        // 슬롯별 설정 가져오기
-        const slotConfig = this.getSlotConfig(slot);
-        const finalHopLimit = hopLimit ?? slotConfig.hop_limit;
-        const vectorThreshold = slotConfig.vector_threshold;
-        // 검색 옵션 기본값
-        const limit = options?.limit ?? 10;
-        const minResults = options?.min_results ?? 3;
-        const useRelations = options?.use_relations ?? true; // 기본값: true
-        // VectorSearchEngine이 없으면 에러
-        if (!this.vectorSearchEngine) {
-            throw new Error('VectorSearchEngine is not set. Call setVectorSearchEngine() first.');
-        }
-        // N-hop 검색 구현 (use_relations 옵션에 따라 관계 그래프 사용 여부 결정)
-        const allHopResults = await this.searchNHop(anchorEmbedding.embedding, anchorEmbedding.provider, anchorMemoryId, vectorThreshold, finalHopLimit, limit * 2, // 더 많이 가져와서 필터링 후 최종 limit 적용
-        useRelations // 관계 그래프 사용 여부 전달
-        );
-        // 쿼리가 있는 경우 쿼리 기반 필터링
-        let filteredResults = allHopResults;
-        let queryEmbeddingForReanchor;
-        if (query && query.trim().length > 0) {
-            filteredResults = await this.filterByQuery(query, allHopResults, anchorEmbedding.provider);
-            // 자동 앵커 이동을 위한 쿼리 임베딩 생성 (선택적, 비동기)
-            try {
-                const queryEmbeddingResult = await this.queryEmbeddingService.generateEmbedding(query);
-                if (queryEmbeddingResult && queryEmbeddingResult.embedding) {
-                    queryEmbeddingForReanchor = queryEmbeddingResult.embedding;
-                }
-            }
-            catch (error) {
-                // 쿼리 임베딩 생성 실패는 무시 (자동 이동은 선택적)
-                logger.debug('Query embedding generation failed (for auto anchor move)', {
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
-        }
-        // 결과 포맷팅
-        const formattedResults = filteredResults.map(result => ({
-            id: result.memory_id,
-            content: result.content,
-            type: result.type,
-            similarity: result.similarity,
-            hop_distance: result.hop_distance,
-            importance: result.importance,
-            created_at: result.created_at,
-            tags: result.tags
-        }));
-        // 최종 limit 적용
-        const localResults = formattedResults.slice(0, limit);
-        const localCount = localResults.length;
-        // Fallback 체크 (query가 있을 때만, min_results 미만 시)
-        let fallbackUsed = false;
-        let finalResults = localResults;
-        let totalCount = localCount;
-        if (query && query.trim().length > 0 && localCount < minResults) {
-            try {
-                logger.info('Fallback to global search', {
-                    localCount,
-                    minResults
-                });
-                // Fallback 수행
-                const fallbackResult = await this.fallbackToGlobalSearch(query, { ...options, limit: limit - localCount }, // 부족한 만큼만 가져오기
-                startTime);
-                fallbackUsed = true;
-                // Local 결과와 Fallback 결과 병합
-                // Local 결과를 우선하고, 중복 제거 (memory_id 기준)
-                const localMemoryIds = new Set(localResults.map(r => r.id));
-                const fallbackItems = fallbackResult.items
-                    .filter(item => !localMemoryIds.has(item.id))
-                    .map(item => ({
-                    id: item.id,
-                    content: item.content,
-                    type: item.type,
-                    similarity: item.similarity ?? 0,
-                    hop_distance: item.hop_distance ?? 999, // fallback 결과는 hop_distance가 없으므로 큰 값으로 설정
-                    importance: item.importance ?? 0.5,
-                    created_at: item.created_at ?? new Date().toISOString(),
-                    tags: item.tags ?? undefined
-                }));
-                // Local 결과 + Fallback 결과 (중복 제거된 것만)
-                finalResults = [...localResults, ...fallbackItems].slice(0, limit);
-                totalCount = finalResults.length;
-                logger.info('Fallback completed', {
-                    localCount,
-                    fallbackCount: fallbackItems.length,
-                    totalCount
-                });
-            }
-            catch (error) {
-                logger.error('Fallback failed', {
-                    error: error instanceof Error ? error.message : String(error)
-                });
-                // Fallback 실패 시 local 결과만 반환
-                fallbackUsed = false;
-            }
-        }
-        const queryTime = Date.now() - startTime;
-        return {
-            items: finalResults,
-            total_count: totalCount,
-            local_results_count: localCount,
-            fallback_used: fallbackUsed,
-            query_time: queryTime,
-            anchor_info: {
-                agent_id: agentId,
-                slot: slot,
-                memory_id: anchorMemoryId
-            }
-        };
-    }
-    /**
-     * 1-hop 검색: 앵커와 직접적으로 유사한 메모리 검색
-     */
-    async searchOneHop(anchorEmbedding, provider, anchorMemoryId, threshold, limit) {
-        if (!this.vectorSearchEngine || !this.db) {
-            throw new Error('VectorSearchEngine or Database is not set.');
-        }
-        try {
-            // VectorSearchEngine 초기화 확인
-            if (typeof this.vectorSearchEngine.initialize === 'function') {
-                this.vectorSearchEngine.initialize(this.db);
-            }
-            // 벡터 검색 실행 (임계값은 낮게 설정하고 나중에 필터링)
-            const searchResults = await this.vectorSearchEngine.search(anchorEmbedding, {
-                limit: limit + 1, // 자기 자신 제외를 위해 +1
-                threshold: 0.0, // 임계값은 나중에 필터링에서 적용
-                includeContent: true,
-                includeMetadata: true
-            }, provider);
-            // 결과 필터링: 앵커 메모리 제외, 유사도 임계값 이상만 반환
-            const filteredResults = searchResults
-                .filter(result => {
-                // 앵커 메모리 제외
-                if (result.memory_id === anchorMemoryId) {
-                    return false;
-                }
-                // 유사도 임계값 이상만 반환
-                return result.similarity >= threshold;
-            })
-                .slice(0, limit); // 최종 limit 적용
-            return filteredResults;
-        }
-        catch (error) {
-            logger.error('1-hop search failed', {
-                error: error instanceof Error ? error.message : String(error)
-            });
-            throw new Error(`Failed to perform 1-hop search: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    /**
-     * N-hop 검색: 앵커를 기준으로 최대 N-hop까지 확장 검색
-     */
-    async searchNHop(anchorEmbedding, provider, anchorMemoryId, threshold, maxHops, limit, useRelations = true) {
-        if (!this.vectorSearchEngine || !this.db) {
-            throw new Error('VectorSearchEngine or Database is not set.');
-        }
-        // VectorSearchEngine 초기화 확인
-        if (typeof this.vectorSearchEngine.initialize === 'function') {
-            this.vectorSearchEngine.initialize(this.db);
-        }
-        // 이미 발견된 메모리 ID 추적 (중복 방지)
-        const discoveredMemoryIds = new Set([anchorMemoryId]);
-        // 각 hop 레벨의 결과를 저장
-        const allResults = [];
-        // 현재 hop 레벨의 메모리들 (임베딩 포함)
-        // 1-hop: 앵커 임베딩을 사용
-        let currentHopMemories = [
-            { memory_id: anchorMemoryId, embedding: anchorEmbedding }
-        ];
-        // 각 hop 레벨별로 검색 수행
-        for (let hop = 1; hop <= maxHops; hop++) {
-            const nextHopMemories = [];
-            const hopResults = [];
-            // 현재 hop의 각 메모리에 대해 검색 수행
-            for (const currentMemory of currentHopMemories) {
-                try {
-                    // 관계 그래프 또는 memory_link를 활용한 직접 연결된 메모리 조회
-                    // use_relations가 false이면 관계 그래프를 사용하지 않음
-                    const linkedMemories = useRelations
-                        ? await this.getLinkedMemories(currentMemory.memory_id)
-                        : [];
-                    // 벡터 검색 실행
-                    const vectorSearchResults = await this.vectorSearchEngine.search(currentMemory.embedding, {
-                        limit: Math.ceil(limit / maxHops) + 10, // 각 hop당 충분한 결과 가져오기
-                        threshold: 0.0, // 임계값은 나중에 필터링에서 적용
-                        includeContent: true,
-                        includeMetadata: true
-                    }, provider);
-                    // memory_link 결과와 벡터 검색 결과를 병합
-                    const allCandidates = new Map();
-                    // memory_link 결과 추가 (우선순위 높음)
-                    for (const linked of linkedMemories) {
-                        if (!discoveredMemoryIds.has(linked.memory_id)) {
-                            allCandidates.set(linked.memory_id, {
-                                ...linked,
-                                isLinked: true
-                            });
-                        }
-                    }
-                    // 벡터 검색 결과 추가
-                    const relaxedThreshold = threshold * 0.5;
-                    for (const result of vectorSearchResults) {
-                        if (!allCandidates.has(result.memory_id) && !discoveredMemoryIds.has(result.memory_id)) {
-                            if (result.similarity >= relaxedThreshold) {
-                                allCandidates.set(result.memory_id, {
-                                    ...result,
-                                    isLinked: false
-                                });
-                            }
-                        }
-                        else if (allCandidates.has(result.memory_id)) {
-                            // memory_link로 이미 추가된 경우, 유사도 정보 업데이트
-                            const existing = allCandidates.get(result.memory_id);
-                            existing.similarity = Math.max(existing.similarity, result.similarity);
-                        }
-                    }
-                    // 결과 필터링 및 추가
-                    for (const [memoryId, candidate] of allCandidates.entries()) {
-                        if (discoveredMemoryIds.has(memoryId)) {
-                            continue;
-                        }
-                        const effectiveThreshold = candidate.isLinked
-                            ? threshold * 0.8
-                            : threshold;
-                        if (candidate.similarity < effectiveThreshold) {
-                            continue;
-                        }
-                        discoveredMemoryIds.add(memoryId);
-                        hopResults.push({
-                            memory_id: candidate.memory_id,
-                            content: candidate.content,
-                            type: candidate.type,
-                            similarity: candidate.similarity,
-                            importance: candidate.importance,
-                            created_at: candidate.created_at,
-                            tags: candidate.tags,
-                            hasRelation: candidate.isLinked // 관계가 있는 기억 표시
-                        });
-                        // 다음 hop을 위한 임베딩 조회
-                        if (hop < maxHops) {
-                            try {
-                                const nextEmbedding = await this.cacheService.getAnchorEmbedding(candidate.memory_id);
-                                if (nextEmbedding && nextEmbedding.embedding) {
-                                    nextHopMemories.push({
-                                        memory_id: candidate.memory_id,
-                                        embedding: nextEmbedding.embedding
-                                    });
-                                }
-                            }
-                            catch (error) {
-                                // 임베딩 조회 실패 시 다음 hop에서 제외
-                                logger.debug('Skipping memory for next hop (no embedding)', {
-                                    memoryId: candidate.memory_id,
-                                    error: error instanceof Error ? error.message : String(error)
-                                });
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    logger.error('Hop search failed', {
-                        hop,
-                        memoryId: currentMemory.memory_id,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                    continue;
-                }
-            }
-            // 현재 hop의 결과를 전체 결과에 추가
-            for (const result of hopResults) {
-                allResults.push({
-                    ...result,
-                    hop_distance: hop,
-                    hasRelation: result.hasRelation ?? false
-                });
-            }
-            // limit에 도달했으면 중단
-            if (allResults.length >= limit) {
-                break;
-            }
-            // 다음 hop을 위한 메모리가 없으면 중단
-            if (nextHopMemories.length === 0) {
-                break;
-            }
-            // 다음 hop을 위한 메모리로 업데이트
-            currentHopMemories = nextHopMemories;
-        }
-        // 랭킹 점수 계산 및 적용 (관계 그래프 가중치 포함)
-        const rankedResults = await Promise.all(allResults.map(async (result) => {
-            // 관계 가중치 계산 (관계 그래프가 있고 use_relations가 true인 경우)
-            let relationWeight = 0;
-            let hasRelation = result.hasRelation ?? false;
-            if (useRelations && this.relationGraph) {
-                try {
-                    const relations = await this.relationGraph.getRelations(result.memory_id, {
-                        direction: 'both',
-                        minConfidence: 0.5
-                    });
-                    if (relations.length > 0) {
-                        hasRelation = true; // 관계가 있음을 표시
-                        // 관계 가중치 계산 (간단한 평균)
-                        const avgConfidence = relations.reduce((sum, r) => sum + r.confidence, 0) / relations.length;
-                        const avgBoost = relations.reduce((sum, r) => sum + this.getRelationTypeBoost(r.relation_type), 0) / relations.length;
-                        relationWeight = Math.min(1.0, avgConfidence * avgBoost);
-                    }
-                }
-                catch (error) {
-                    // 관계 조회 실패는 무시
-                    logger.debug('Relation weight calculation failed', {
-                        memoryId: result.memory_id,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            const rankingScore = this.calculateRankingScore(result.similarity, result.hop_distance, result.importance, relationWeight, hasRelation // 관계가 있는 기억에 우선순위 부여
-            );
-            return {
-                ...result,
-                similarity: rankingScore,
-                hasRelation
-            };
-        }));
-        // 랭킹 점수 기준으로 정렬 (관계가 있는 기억 우선)
-        rankedResults.sort((a, b) => {
-            // 관계가 있는 기억에 우선순위 부여
-            if (a.hasRelation && !b.hasRelation) {
-                return -1; // a가 우선
-            }
-            if (!a.hasRelation && b.hasRelation) {
-                return 1; // b가 우선
-            }
-            // 둘 다 관계가 있거나 둘 다 없는 경우, similarity 기준 정렬
-            if (Math.abs(a.similarity - b.similarity) < 0.001) {
-                return a.hop_distance - b.hop_distance;
-            }
-            return b.similarity - a.similarity;
-        });
-        // 최종 limit 적용
-        return rankedResults.slice(0, limit);
-    }
-    /**
-     * 쿼리 기반 필터링
-     */
-    async filterByQuery(query, results, provider) {
-        if (results.length === 0) {
-            return results;
-        }
-        try {
-            // 쿼리 임베딩 생성
-            const queryEmbeddingResult = await this.queryEmbeddingService.generateEmbedding(query);
-            if (!queryEmbeddingResult || !queryEmbeddingResult.embedding) {
-                logger.warn('Query embedding generation failed, skipping filter');
-                return results;
-            }
-            const queryEmbedding = queryEmbeddingResult.embedding;
-            // 각 결과 메모리의 임베딩 조회 및 쿼리 유사도 계산
-            const resultsWithQuerySimilarity = await Promise.all(results.map(async (result) => {
-                try {
-                    const memoryEmbedding = await this.cacheService.getAnchorEmbedding(result.memory_id);
-                    if (!memoryEmbedding || !memoryEmbedding.embedding) {
-                        return {
-                            ...result,
-                            query_similarity: 0,
-                            combined_similarity: result.similarity * 0.5
-                        };
-                    }
-                    // 쿼리 임베딩과 메모리 임베딩 간 유사도 계산
-                    let querySim = 0;
-                    if (queryEmbedding.length === memoryEmbedding.embedding.length) {
-                        querySim = this.cosineSimilarity(queryEmbedding, memoryEmbedding.embedding);
-                    }
-                    else {
-                        // 차원이 다르면 텍스트 기반 간단한 매칭
-                        const queryLower = query.toLowerCase();
-                        const contentLower = result.content.toLowerCase();
-                        const queryWords = queryLower.split(/\s+/);
-                        const matchCount = queryWords.filter(word => contentLower.includes(word)).length;
-                        querySim = matchCount / Math.max(queryWords.length, 1);
-                    }
-                    const baseRankingScore = this.calculateRankingScore(result.similarity, result.hop_distance, result.importance, 0 // query filtering에서는 관계 가중치 미사용 (이미 searchNHop에서 적용됨)
-                    );
-                    const combinedSimilarity = baseRankingScore * 0.6 + querySim * 0.4;
-                    return {
-                        ...result,
-                        query_similarity: querySim,
-                        combined_similarity: combinedSimilarity
-                    };
-                }
-                catch (error) {
-                    logger.error('Query filtering failed for memory', {
-                        memoryId: result.memory_id,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                    return {
-                        ...result,
-                        query_similarity: 0,
-                        combined_similarity: result.similarity * 0.5
-                    };
-                }
-            }));
-            // 쿼리 유사도 임계값 적용
-            const queryThreshold = 0.3;
-            const filtered = resultsWithQuerySimilarity.filter(r => r.query_similarity >= queryThreshold || r.combined_similarity >= 0.5);
-            // 결합 유사도 기준으로 재정렬
-            filtered.sort((a, b) => {
-                if (Math.abs(a.combined_similarity - b.combined_similarity) < 0.001) {
-                    return a.hop_distance - b.hop_distance;
-                }
-                return b.combined_similarity - a.combined_similarity;
-            });
-            // 원본 similarity를 combined_similarity로 업데이트하여 반환
-            return filtered.map(r => ({
-                ...r,
-                similarity: r.combined_similarity
-            }));
-        }
-        catch (error) {
-            logger.error('Query-based filtering failed', {
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return results;
-        }
-    }
-    /**
-     * 전역 검색으로 Fallback
-     */
-    async fallbackToGlobalSearch(query, options, startTime) {
-        if (!this.hybridSearchEngine) {
-            throw new Error('HybridSearchEngine is not set. Call setHybridSearchEngine() first.');
-        }
-        if (!this.db) {
-            throw new Error('Database is not set.');
-        }
-        const limit = options?.limit ?? 10;
-        const fallbackStartTime = Date.now();
-        try {
-            // HybridSearchEngine을 사용한 전역 검색
-            const globalSearchResult = await this.hybridSearchEngine.search(this.db, {
-                query: query,
-                limit: limit,
-                vectorWeight: options?.vector_weight,
-                textWeight: options?.text_weight
-            });
-            // HybridSearchResult를 SearchResult 형식으로 변환
-            const convertedItems = globalSearchResult.items.map(item => ({
-                id: item.id,
-                content: item.content,
-                type: item.type,
-                similarity: item.finalScore,
-                importance: item.importance,
-                created_at: item.created_at,
-                tags: item.tags,
-                hop_distance: undefined
-            }));
-            const queryTime = startTime ? Date.now() - startTime : Date.now() - fallbackStartTime;
-            return {
-                items: convertedItems,
-                total_count: convertedItems.length,
-                local_results_count: 0,
-                fallback_used: true,
-                query_time: queryTime
-            };
-        }
-        catch (error) {
-            logger.error('Global search fallback failed', {
-                error: error instanceof Error ? error.message : String(error)
-            });
-            const queryTime = startTime ? Date.now() - startTime : 0;
-            return {
-                items: [],
-                total_count: 0,
-                local_results_count: 0,
-                fallback_used: true,
-                query_time: queryTime
-            };
-        }
-    }
-    /**
-     * memory_link 테이블을 활용한 직접 연결된 메모리 조회
-     */
-    /**
-     * 연결된 메모리 조회
-     * 관계 그래프가 있으면 우선 사용, 없으면 memory_link 사용
-     */
-    async getLinkedMemories(memoryId) {
-        if (!this.db) {
-            return [];
-        }
-        try {
-            // 관계 그래프가 있으면 우선 사용
-            if (this.relationGraph) {
-                const relations = await this.relationGraph.getRelations(memoryId, {
-                    direction: 'outgoing',
-                    minConfidence: 0.5
-                });
-                if (relations.length > 0) {
-                    // 관계를 메모리 정보와 결합
-                    const memoryIds = relations.map(r => r.target_id);
-                    const placeholders = memoryIds.map(() => '?').join(',');
-                    const memoryRecords = this.db.prepare(`
-            SELECT id, content, type, importance, created_at, tags
-            FROM memory_item
-            WHERE id IN (${placeholders})
-          `).all(...memoryIds);
-                    // 관계 정보와 메모리 정보 결합
-                    const memoryMap = new Map(memoryRecords.map(m => [m.id, m]));
-                    return relations.map(relation => {
-                        const memory = memoryMap.get(relation.target_id);
-                        if (!memory) {
-                            return null;
-                        }
-                        // 관계 confidence를 similarity로 사용 (관계가 있으면 높은 유사도)
-                        // 관계 유형별 부스트 적용
-                        const typeBoost = this.getRelationTypeBoost(relation.relation_type);
-                        const similarity = Math.min(1.0, relation.confidence * typeBoost);
-                        return {
-                            memory_id: memory.id,
-                            content: memory.content,
-                            type: memory.type,
-                            similarity,
-                            importance: memory.importance,
-                            created_at: memory.created_at,
-                            tags: memory.tags ? JSON.parse(memory.tags) : undefined
-                        };
-                    }).filter((item) => item !== null);
-                }
-            }
-            // 관계 그래프가 없거나 관계가 없으면 memory_link 사용 (하위 호환성)
-            const linkedRecords = this.db.prepare(`
-        SELECT 
-          ml.target_id as memory_id,
-          mi.content,
-          mi.type,
-          mi.importance,
-          mi.created_at,
-          mi.tags,
-          ml.relation_type
-        FROM memory_link ml
-        JOIN memory_item mi ON mi.id = ml.target_id
-        WHERE ml.source_id = ?
-        ORDER BY ml.created_at DESC
-      `).all(memoryId);
-            return linkedRecords.map(record => ({
-                memory_id: record.memory_id,
-                content: record.content,
-                type: record.type,
-                similarity: 0.9, // memory_link는 기본 유사도 0.9
-                importance: record.importance,
-                created_at: record.created_at,
-                tags: record.tags ? (typeof record.tags === 'string' ? JSON.parse(record.tags) : record.tags) : undefined
-            }));
-        }
-        catch (error) {
-            logger.error('memory_link retrieval failed', {
-                memoryId,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return [];
-        }
-    }
-    /**
-     * 관계 유형별 부스트 가중치 반환
-     */
-    getRelationTypeBoost(relationType) {
-        const boostMap = {
-            'CAUSES': 1.2,
-            'DEPENDS_ON': 1.1,
-            'FOLLOWS': 1.0,
-            'CONTRASTS_WITH': 0.9,
-            'REFERENCES': 0.8,
-            'BELONGS_TO': 1.0
-        };
-        return boostMap[relationType] || 1.0;
-    }
-    /**
-     * 검색 결과 랭킹 점수 계산
-     * 관계 그래프와 벡터 유사도를 결합한 하이브리드 hop 점수 계산
-     * 관계가 있는 기억에 우선순위 부여
-     */
-    calculateRankingScore(similarity, hopDistance, importance = 0.5, relationWeight = 0, hasRelation = false) {
-        const hopDecayFactor = 1.0 / (1.0 + (hopDistance - 1) * 0.3);
-        const anchorProximityBoost = hopDistance === 1 ? 1.2 : 1.0;
-        const importanceWeight = 0.1;
-        const importanceBoost = 1.0 + (importance - 0.5) * importanceWeight;
-        // 관계 가중치가 있으면 벡터 유사도와 결합
-        let combinedSimilarity = similarity;
-        if (relationWeight > 0) {
-            // 관계 가중치와 벡터 유사도를 가중 평균으로 결합
-            // 관계 가중치: 30%, 벡터 유사도: 70%
-            combinedSimilarity = similarity * 0.7 + relationWeight * 0.3;
-        }
-        // 관계가 있는 기억에 우선순위 부스트 적용
-        const relationPriorityBoost = hasRelation ? 1.15 : 1.0; // 15% 부스트
-        const rankingScore = Math.min(1.0, combinedSimilarity * hopDecayFactor * anchorProximityBoost * importanceBoost * relationPriorityBoost);
-        return rankingScore;
-    }
-    /**
-     * 코사인 유사도 계산
-     */
-    cosineSimilarity(a, b) {
-        if (a.length !== b.length) {
-            throw new Error('벡터 차원이 일치하지 않습니다');
-        }
-        let dotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            const aVal = a[i] ?? 0;
-            const bVal = b[i] ?? 0;
-            dotProduct += aVal * bVal;
-            normA += aVal * aVal;
-            normB += bVal * bVal;
-        }
-        const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-        return magnitude === 0 ? 0 : dotProduct / magnitude;
-    }
-    /**
-     * 슬롯별 설정 조회
-     */
-    getSlotConfig(slot) {
-        const slotConfig = {
-            A: { hop_limit: 1, vector_threshold: 0.8 },
-            B: { hop_limit: 2, vector_threshold: 0.6 },
-            C: { hop_limit: 3, vector_threshold: 0.4 }
-        };
-        return slotConfig[slot];
-    }
-    /**
-     * 자동 앵커 이동 점수 계산
-     */
-    async calculateReanchorScore(memoryId, queryEmbedding, anchorEmbedding) {
-        if (!this.db) {
-            return 0;
-        }
-        try {
-            const memory = this.db.prepare(`
-        SELECT 
-          view_count,
-          cite_count,
-          edit_count,
-          last_accessed,
-          created_at,
-          importance
-        FROM memory_item
-        WHERE id = ?
-      `).get(memoryId);
-            if (!memory) {
-                return 0;
-            }
-            const usageScore = Math.min(1.0, (Math.log(1 + memory.view_count) +
-                2 * Math.log(1 + memory.cite_count) +
-                0.5 * Math.log(1 + memory.edit_count)) / 10);
-            let recencyScore = 0.5;
-            if (memory.last_accessed) {
-                const lastAccessed = new Date(memory.last_accessed);
-                const now = new Date();
-                const daysSinceAccess = (now.getTime() - lastAccessed.getTime()) / (1000 * 60 * 60 * 24);
-                recencyScore = Math.max(0, 1.0 - daysSinceAccess / 30);
-            }
-            const importanceScore = memory.importance || 0.5;
-            let semanticScore = 0.5;
-            if (queryEmbedding) {
-                const memoryEmbedding = await this.cacheService.getAnchorEmbedding(memoryId);
-                if (memoryEmbedding && memoryEmbedding.embedding) {
-                    const similarity = this.cosineSimilarity(queryEmbedding, memoryEmbedding.embedding);
-                    semanticScore = similarity;
-                }
-            }
-            let anchorComparisonScore = 0.5;
-            if (anchorEmbedding) {
-                const memoryEmbedding = await this.cacheService.getAnchorEmbedding(memoryId);
-                if (memoryEmbedding && memoryEmbedding.embedding) {
-                    const similarity = this.cosineSimilarity(anchorEmbedding, memoryEmbedding.embedding);
-                    anchorComparisonScore = 1.0 - similarity;
-                }
-            }
-            const finalScore = usageScore * 0.3 +
-                recencyScore * 0.2 +
-                importanceScore * 0.2 +
-                semanticScore * 0.2 +
-                anchorComparisonScore * 0.1;
-            return Math.min(1.0, Math.max(0.0, finalScore));
-        }
-        catch (error) {
-            logger.error('Reanchor score calculation failed', {
-                memoryId,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return 0;
-        }
-    }
-    /**
-     * 앵커 주변 메모리 사용 패턴 분석
-     */
-    async analyzeAnchorUsage(agentId, slot, anchorMemoryId, anchorEmbedding, queryEmbedding) {
-        if (!this.db) {
-            throw new Error('Database is not set.');
-        }
-        try {
-            const slotConfig = this.getSlotConfig(slot);
-            const nearbyMemories = await this.searchNHop(anchorEmbedding.embedding, anchorEmbedding.provider, anchorMemoryId, slotConfig.vector_threshold * 0.8, slotConfig.hop_limit, 20);
-            const candidates = [];
-            for (const memory of nearbyMemories) {
-                const score = await this.calculateReanchorScore(memory.memory_id, queryEmbedding, anchorEmbedding.embedding);
-                if (score > 0.5) {
-                    const reason = this.generateReanchorReason(memory, score);
-                    candidates.push({
-                        memory_id: memory.memory_id,
-                        score,
-                        reason
-                    });
-                }
-            }
-            candidates.sort((a, b) => b.score - a.score);
-            return candidates;
-        }
-        catch (error) {
-            logger.error('Anchor usage analysis failed', {
-                agentId,
-                slot,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return [];
-        }
-    }
-    /**
-     * 앵커 이동 이유 생성
-     */
-    generateReanchorReason(memory, score) {
-        const reasons = [];
-        if (score > 0.7) {
-            reasons.push('높은 사용 빈도');
-        }
-        if (memory.similarity && memory.similarity > 0.8) {
-            reasons.push('쿼리와 높은 유사도');
-        }
-        if (memory.hop_distance === 1) {
-            reasons.push('앵커와 직접 연결');
-        }
-        return reasons.length > 0 ? reasons.join(', ') : '종합 점수 우수';
-    }
-    /**
-     * 자동 앵커 이동 실행
-     */
-    async autoReanchor(agentId, slot, anchorManager, queryEmbedding, threshold = 0.7, strategy = 'gradual') {
-        if (!this.db) {
-            throw new Error('Database is not set.');
-        }
-        try {
-            const currentAnchor = await anchorManager.getAnchor(agentId, slot);
-            if (!currentAnchor || Array.isArray(currentAnchor) || !currentAnchor.memory_id) {
-                return {
-                    moved: false,
-                    old_anchor: null,
-                    new_anchor: null,
-                    score: 0,
-                    reason: '앵커가 설정되지 않았습니다'
-                };
-            }
-            const anchorEmbedding = await this.cacheService.getAnchorEmbedding(currentAnchor.memory_id);
-            if (!anchorEmbedding) {
-                return {
-                    moved: false,
-                    old_anchor: currentAnchor.memory_id,
-                    new_anchor: null,
-                    score: 0,
-                    reason: '앵커 임베딩을 찾을 수 없습니다'
-                };
-            }
-            const candidates = await this.analyzeAnchorUsage(agentId, slot, currentAnchor.memory_id, anchorEmbedding, queryEmbedding);
-            if (candidates.length === 0 || !candidates[0] || candidates[0].score < threshold) {
-                return {
-                    moved: false,
-                    old_anchor: currentAnchor.memory_id,
-                    new_anchor: null,
-                    score: candidates[0]?.score || 0,
-                    reason: `임계값(${threshold}) 미만 또는 후보 없음`
-                };
-            }
-            const bestCandidate = candidates[0];
-            if (!bestCandidate) {
-                return {
-                    moved: false,
-                    old_anchor: currentAnchor.memory_id,
-                    new_anchor: null,
-                    score: 0,
-                    reason: '후보 없음'
-                };
-            }
-            if (strategy === 'gradual') {
-                if (slot === 'A') {
-                    const bAnchor = await anchorManager.getAnchor(agentId, 'B');
-                    if (bAnchor && !Array.isArray(bAnchor) && bAnchor.memory_id) {
-                        await anchorManager.setAnchor(agentId, bAnchor.memory_id, 'C');
-                    }
-                    await anchorManager.setAnchor(agentId, currentAnchor.memory_id, 'B');
-                }
-                else if (slot === 'B') {
-                    await anchorManager.setAnchor(agentId, currentAnchor.memory_id, 'C');
-                }
-                await anchorManager.setAnchor(agentId, bestCandidate.memory_id, slot);
-            }
-            else {
-                await anchorManager.setAnchor(agentId, bestCandidate.memory_id, slot);
-            }
-            logger.info('Auto reanchor completed', {
-                agentId,
-                slot,
-                oldAnchor: currentAnchor.memory_id,
-                newAnchor: bestCandidate.memory_id,
-                score: bestCandidate.score,
-                reason: bestCandidate.reason
-            });
-            return {
-                moved: true,
-                old_anchor: currentAnchor.memory_id,
-                new_anchor: bestCandidate.memory_id,
-                score: bestCandidate.score,
-                reason: bestCandidate.reason
-            };
-        }
-        catch (error) {
-            logger.error('Auto reanchor failed', {
-                agentId,
-                slot,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            throw error;
-        }
-    }
-    /**
-     * 검색 후 자동 앵커 이동 체크
-     */
-    async checkAndAutoReanchor(agentId, slot, anchorManager, queryEmbedding, autoMoveEnabled = false) {
-        if (!autoMoveEnabled) {
-            return null;
-        }
-        try {
-            return await this.autoReanchor(agentId, slot, anchorManager, queryEmbedding, 0.7, 'gradual');
-        }
-        catch (error) {
-            logger.debug('Auto reanchor check failed (ignored)', {
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return null;
-        }
-    }
-}
-//# sourceMappingURL=anchor-search-service.js.map