/**
 * Semantic Memory 갱신 서비스
 *
 * Triple 추출 결과를 기반으로 Semantic Memory를 생성하거나 업데이트합니다.
 *
 * 주요 기능:
 * - Triple 기반 Semantic Memory 생성/업데이트
 * - 중복 판단 및 병합
 * - Confidence 계산 (구조적 검증 기반)
 * - 중요도 계산
 */
import Database from 'better-sqlite3';
import type { TripleExtractionResult } from '../../../../shared/types/triple-extraction.js';
import { UnifiedEmbeddingService } from '../../../embedding/services/unified-embedding-service.js';
import type { RelationGraphPort } from '../../../relation/ports/relation-graph.port.js';
import { KgTripleRepository } from '../../repositories/kg-triple-repository.js';
/**
 * Semantic Memory 업데이트 결과
 */
export interface SemanticMemoryUpdateResult {
    created: number;
    updated: number;
    skipped: number;
    semanticMemoryIds: string[];
}
/**
 * Semantic Memory 업데이트 옵션
 */
export interface SemanticMemoryUpdateOptions {
    /**
     * Episodic Memory ID (관계 생성용)
     */
    episodicMemoryId: string;
    /**
     * Episodic Memory 중요도 (중요도 계산용)
     */
    episodicImportance?: number;
    /**
     * Confidence 임계값 (기본값: 0.7)
     *
     * PRD 2.4: 신뢰도가 일정 수준 이상인 경우만 Semantic Memory 생성
     * 이 값보다 낮은 confidence를 가진 triple은 Semantic Memory로 변환하지 않음
     * 설정 가능하며, 미지정 시 기본값 0.7 사용
     */
    confidenceThreshold?: number;
    /**
     * Subject/Object 유사도 임계값 (기본값: 0.9)
     */
    similarityThreshold?: number;
}
/**
 * Semantic Memory 갱신 서비스
 */
export declare class SemanticMemoryUpdateService {
    private db;
    private readonly canonicalizer;
    private readonly entityLinker;
    private readonly embeddingService;
    private readonly relationGraph;
    private readonly statistics;
    private readonly kgTripleRepo;
    /**
     * Confidence 임계값 기본값 (PRD 2.4 참고)
     * 신뢰도가 이 값 이상인 경우만 Semantic Memory 생성
     */
    private readonly DEFAULT_CONFIDENCE_THRESHOLD;
    /**
     * Subject/Object 유사도 임계값 기본값
     * 중복 판단 시 사용되는 유사도 임계값
     */
    private readonly DEFAULT_SIMILARITY_THRESHOLD;
    constructor(db: Database.Database, relationGraph: RelationGraphPort, embeddingService?: UnifiedEmbeddingService, kgTripleRepo?: KgTripleRepository);
    /**
     * 런타임 relation_type_registry 등록
     *
     * extracted_from와 supported_by 관계 타입이 없을 경우 자동 등록합니다.
     * 마이그레이션에서 초기 데이터 삽입은 처리되지만, 런타임에 없을 경우를 대비합니다.
     */
    private ensureRelationTypes;
    /**
     * Triple 배열을 기반으로 Semantic Memory를 생성하거나 업데이트합니다.
     *
     * @param extractionResult Triple 추출 결과
     * @param options 업데이트 옵션
     * @returns 업데이트 결과
     */
    updateSemanticMemory(extractionResult: TripleExtractionResult, options: SemanticMemoryUpdateOptions): Promise<SemanticMemoryUpdateResult>;
    /**
     * 입력 검증
     *
     * Given: extractionResult가 주어졌을 때
     * When: triples 배열이 비어있는지 검증
     * Then: 비어있으면 빈 결과 반환, 아니면 null 반환
     *
     * @param extractionResult Triple 추출 결과
     * @returns 빈 결과 또는 null
     */
    private validateInput;
    /**
     * 업데이트 데이터 준비
     *
     * Given: options가 주어졌을 때
     * When: 임계값 설정 및 초기 데이터 준비
     * Then: 준비된 데이터 반환
     *
     * @param options 업데이트 옵션
     * @returns 준비된 데이터
     */
    private prepareUpdateData;
    /**
     * 각 Triple 처리
     *
     * Given: extractionResult, options, preparedData가 주어졌을 때
     * When: 각 triple을 순차적으로 처리
     * Then: 처리 결과 반환
     *
     * @param extractionResult Triple 추출 결과
     * @param options 업데이트 옵션
     * @param preparedData 준비된 데이터
     * @returns 처리 결과
     */
    private applyUpdates;
    /**
     * 단일 Triple 처리
     *
     * Given: triple, extractionInfo, options, 임계값들이 주어졌을 때
     * When: 단일 triple을 처리하여 Semantic Memory 생성/업데이트
     * Then: 처리 결과 반환
     *
     * @param triple 처리할 Triple
     * @param extractionInfo 추출 정보
     * @param options 업데이트 옵션
     * @param confidenceThreshold Confidence 임계값
     * @param similarityThreshold 유사도 임계값
     * @param result 결과 객체 (수정됨)
     * @returns 처리된 confidence
     */
    private processSingleTriple;
    /**
     * 통계 수집 및 리스너 알림
     *
     * Given: 처리 결과가 주어졌을 때
     * When: 통계를 수집하고 리스너에게 알림
     * Then: statistics.recordUpdate가 호출됨
     *
     * @param result 처리 결과
     * @param totalTriples 전체 Triple 개수
     * @param confidences Confidence 배열
     * @param processingStartTime 처리 시작 시간
     * @param hasError 에러 발생 여부
     */
    private notifyListeners;
    /**
     * Semantic Memory 생성 통계 조회
     *
     * PRD 8.2: Semantic Memory 생성 통계
     * - 생성된 Semantic Memory 수
     * - 업데이트된 Semantic Memory 수
     * - 중복 제거된 항목 수
     *
     * @returns Semantic Memory 생성 통계
     */
    getStatistics(): import("./semantic-memory-statistics.js").SemanticMemoryStatistics;
    /**
     * Triple을 자연어로 변환
     *
     * @param subject 정규화된 subject
     * @param predicate 정규화된 predicate
     * @param object 정규화된 object
     * @returns 자연어 문장
     */
    private tripleToNaturalLanguage;
    /**
     * 새로운 Semantic Memory 생성
     *
     * Triple의 predicate, subject, object를 정규화하여 저장합니다.
     *
     * @param triple Triple
     * @param options 업데이트 옵션
     * @param confidence Confidence
     * @returns 생성된 Semantic Memory ID
     */
    private createSemanticMemory;
    /**
     * kg_triple 조회/등록용 정규화 (createSemanticMemory와 동일한 canonicalizer·entityLinker 사용)
     */
    private normalizeTripleForKg;
    /**
     * 기존 Semantic Memory 업데이트 (병합 전략)
     *
     * PRD 2.3 중복 방지 및 병합 전략에 따라:
     * - 유사도가 임계값 이상인 경우 새로운 항목을 생성하지 않고 기존 항목 업데이트
     * - 기존 항목의 중요도 업데이트
     * - Episode Weight 누적: 동일 triple이 여러 Episodic Memory에서 추출된 경우 가중치 증가
     *   * recall_count를 증가시켜 Episode Weight를 추적
     *   * 중요도는 Episode Weight를 반영하여 재계산
     * - 완전히 동일한 Semantic Memory는 생성하지 않음 (중복 판단 로직에서 처리)
     *
     * @param semanticMemoryId Semantic Memory ID
     * @param triple Triple
     * @param options 업데이트 옵션
     * @param confidence Confidence
     */
    private updateExistingSemanticMemory;
    /**
     * 중복 Semantic Memory 검색
     *
     * Triple 요소별 비교 기준 (PRD 2.2 참고):
     * - Predicate: Canonicalization 후 정확히 일치하면 동일한 것으로 처리 (정확 일치만)
     * - Subject: 문자열 정규화 후 일치 여부를 기본으로, 임베딩 유사도를 보조 기준으로 사용
     * - Object: Subject와 동일한 방식 (정규화 + 유사도)
     *
     * 중복 판단 로직:
     * ```
     * if (predicate == predicate' AND
     *     (subject.normalized() == subject'.normalized() OR subject.similarity(subject') > threshold) AND
     *     (object.normalized() == object'.normalized() OR object.similarity(object') > threshold))
     *   → 중복으로 판단
     * ```
     *
     * @param triple Triple
     * @param similarityThreshold 유사도 임계값 (기본값: 0.9)
     * @returns 중복 Semantic Memory (없으면 null)
     */
    private findDuplicateSemanticMemory;
    /**
     * 두 엔티티의 유사도 확인
     *
     * PRD 2.2 중복 판단 기준표에 따라:
     * - 기본 기준: 문자열 정규화 후 일치 여부 (lowercasing, 공백 제거)
     * - 보조 기준: 임베딩 유사도 (임계값 이상이면 유사한 것으로 판단)
     *
     * 정규화: lowercasing, 공백 제거, 한글/영문 혼용 통일 (EntityLinker에서 이미 수행됨)
     *
     * @param entity1 첫 번째 엔티티 (이미 정규화된 값)
     * @param entity2 두 번째 엔티티 (DB에서 조회한 값)
     * @param threshold 유사도 임계값 (기본값: 0.9)
     * @returns 유사도가 임계값 이상이면 true
     */
    private checkSimilarity;
    /**
     * 코사인 유사도 계산
     */
    private cosineSimilarity;
    /**
     * 구조적 검증 기반 Confidence 계산
     *
     * PRD 2.4 신뢰도 기반 필터링 (구조적 검증 방식)에 따라:
     * - LLM 응답에서 confidence 추출은 신뢰할 수 없음 (대부분의 LLM은 신뢰할 수 있는 confidence를 제공하지 않음)
     * - 구조적 검증 기반 confidence 계산 (AriGraph 방식) 사용
     *
     * 각 검증 단계별 점수 부여:
     * 1. Triple 구조의 완전성 검증 (subject, predicate, object 모두 존재): 0.3
     * 2. Predicate 정규화 성공 여부: 0.3
     * 3. Entity linking 성공 여부: 0.4
     *    - Subject와 Object 모두 성공: 0.4
     *    - 하나만 성공: 0.2 (부분 성공)
     *
     * 최종 confidence는 0.0~1.0 범위로 정규화됩니다.
     * 신뢰도가 일정 수준 이상인 경우만 Semantic Memory 생성 (기본 임계값: 0.7)
     *
     * @param triple Triple
     * @param _extractionInfo 추출 정보 (steps 정보 포함)
     * @returns Confidence (0.0~1.0)
     */
    private calculateConfidence;
    /**
     * Semantic Memory 중요도 계산
     *
     * PRD 2.5 Semantic Memory 중요도 계산에 따라:
     * - Triple이 추출된 Episodic Memory의 중요도 반영
     * - 여러 Episodic Memory에서 동일한 Semantic Memory가 추출된 경우 중요도 증가
     *   * Episode Weight 누적: 동일 triple이 여러 Episodic Memory에서 추출된 경우 가중치 증가
     *   * 로그 스케일을 사용하여 증가폭을 제어 (과도한 증가 방지)
     * - 중요도 Decay: 시간이 지나면서 중요도가 감쇠하는지 여부 결정 (초기에는 decay 없음)
     * - 중요도는 0.0~1.0 범위로 정규화
     *
     * 계산 공식:
     * - 기본 중요도 = Episodic Memory 중요도
     * - Episode Weight가 1보다 큰 경우: importance += log(episodeCount + 1) / log(10) * 0.1
     * - 최종 중요도 = min(1.0, max(0.0, importance))
     *
     * @param episodicImportance Triple이 추출된 Episodic Memory의 중요도
     * @param episodeCount Episode Weight (여러 Episodic Memory에서 추출된 횟수)
     * @returns 계산된 중요도 (0.0~1.0)
     */
    private calculateImportance;
    /**
     * 관계 방향 검증
     *
     * data-model(005) / 스키마와 일치:
     * - extracted_from: source Semantic → target Episodic (시맨틱이 해당 에피소딕에서 추출됨)
     * - supported_by: source Episodic → target Semantic (에피소딕이 시맨틱에 의해 지지됨)
     *
     * @param sourceId 소스 Memory ID
     * @param targetId 타겟 Memory ID
     * @param relationType 관계 타입
     * @throws Error 관계 방향이 올바르지 않은 경우
     */
    private validateRelationDirection;
    /**
     * Episodic-Edge 관계 생성
     *
     * PRD 2.4 Confidence 저장 위치 및 연계 방식에 따라:
     * - **주 저장 위치**: `memory_relation` 테이블의 `confidence` 필드
     *   - Episodic Memory와 Semantic Memory 간 관계의 신뢰도로 저장
     *   - 검색/가중치 계산 시: `memory_relation.confidence` 참조
     * - 각 relation 생성 시 계산된 confidence 값을 저장
     *
     * 두 가지 관계를 생성:
     * 1. extracted_from (Semantic → Episodic): 시맨틱이 해당 에피소딕 출처에서 추출됨
     * 2. supported_by (Episodic → Semantic): 에피소딕이 시맨틱 요약에 의해 지지됨
     *
     * 각 관계는 동일한 confidence 값을 가지며, 각 triple별로 독립적인 relation으로 저장됩니다.
     *
     * PRD 3.4 관계 중복 방지:
     * - UNIQUE(source_id, target_id, relation_type) 제약 조건 활용
     * - 동일한 Episodic Memory와 Semantic Memory 간의 동일한 관계 타입은 중복 생성하지 않음
     *
     * @param episodicMemoryId Episodic Memory ID
     * @param semanticMemoryId Semantic Memory ID
     * @param triple Triple
     * @param extractionInfo 추출 정보
     * @param confidence 계산된 Confidence (구조적 검증 기반, 0.0~1.0)
     */
    private createEpisodicEdge;
    private tryCreateEpisodicRelation;
    private isUniqueConstraintError;
}
//# sourceMappingURL=semantic-memory-update-service.d.ts.map