memento-mcp-server 1.13.1-a2 → 1.13.1-a4

package/dist/services/batch-scheduler.js

@@ -1,926 +0,0 @@
-/**
- * 배치 작업 스케줄러
- * TTL 기반 메모리 정리 및 기타 주기적 작업을 자동화
- * Memento MCP Server의 핵심 배치 처리 컴포넌트
- */
-import { ForgettingPolicyService } from './forgetting-policy-service.js';
-import { getPerformanceMonitor } from './performance-monitor.js';
-import { DatabaseUtils } from '../utils/database.js';
-import Database from 'better-sqlite3';
-import fs from 'fs';
-import path from 'path';
-import { ConsolidationScoreWorker } from '../workers/consolidation-score-worker.js';
-import { ReflexionWorker } from './reflexion-worker.js';
-import { mementoConfig } from '../config/index.js';
-import { spawn } from 'child_process';
-import { join } from 'path';
-export class BatchScheduler {
-    config;
-    forgettingService;
-    performanceMonitor;
-    consolidationScoreWorker = null;
-    reflexionWorker = null;
-    db = null;
-    intervals = new Map();
-    isRunning = false;
-    startTime = null;
-    lastExecution = new Map();
-    totalExecutions = new Map();
-    errorCount = new Map();
-    runningJobs = new Set();
-    jobQueue = [];
-    jobProcessorInterval = null;
-    constructor(config) {
-        this.config = {
-            cleanupInterval: 60 * 60 * 1000, // 1시간
-            monitoringInterval: 5 * 60 * 1000, // 5분
-            healthCheckInterval: 30 * 1000, // 30초
-            consolidationScoreIncrementalInterval: 60 * 60 * 1000, // 1시간
-            consolidationScoreFullSweepInterval: 24 * 60 * 60 * 1000, // 24시간
-            consolidationScoreFullSweepHour: 3, // 새벽 3시
-            relationValidationInterval: 7 * 24 * 60 * 60 * 1000, // 7일
-            relationValidationDayOfWeek: 0, // 일요일
-            relationValidationHour: 2, // 새벽 2시
-            maxBatchSize: 1000,
-            enableLogging: true,
-            enableNotifications: false,
-            enableMetrics: true,
-            maxConcurrentJobs: 3,
-            jobTimeout: 5 * 60 * 1000, // 5분
-            retryAttempts: 3,
-            retryDelay: 1000, // 1초
-            ...config
-        };
-        // 생성자에서 설정 검증
-        this.validateConfig();
-        this.forgettingService = new ForgettingPolicyService();
-        this.performanceMonitor = getPerformanceMonitor();
-        // Consolidation Score 기능이 활성화되어 있으면 워커 초기화
-        if (mementoConfig.consolidationScoreEnabled) {
-            this.consolidationScoreWorker = new ConsolidationScoreWorker();
-        }
-    }
-    /**
-     * 스케줄러 시작
-     * @param db 데이터베이스 인스턴스
-     * @param reflexionWorker Reflexion Worker 인스턴스 (선택적)
-     */
-    async start(db, reflexionWorker) {
-        if (this.isRunning) {
-            throw new Error('BatchScheduler is already running');
-        }
-        this.validateConfig();
-        this.db = db;
-        this.isRunning = true;
-        this.startTime = new Date();
-        // 성능 모니터 초기화
-        this.performanceMonitor.initialize(db);
-        // Reflexion Worker 통합 (Phase 2)
-        if (reflexionWorker) {
-            this.reflexionWorker = reflexionWorker;
-            // Reflexion Worker는 이미 bootstrap.ts에서 시작되므로 여기서는 상태 확인만
-            this.log('Reflexion Worker 통합됨', {
-                worker_running: reflexionWorker.getStatus().isRunning
-            });
-        }
-        // 메모리 정리 작업 스케줄링
-        this.scheduleJob('cleanup', this.config.cleanupInterval, async () => { await this.runMemoryCleanup(); }, 1);
-        // 모니터링 작업 스케줄링
-        this.scheduleJob('monitoring', this.config.monitoringInterval, async () => { await this.runMonitoring(); }, 2);
-        // 헬스체크 작업 스케줄링
-        this.scheduleJob('healthcheck', this.config.healthCheckInterval, async () => { await this.runHealthCheck(); }, 3);
-        // Consolidation Score 재계산 작업 스케줄링 (기능 플래그 활성화 시)
-        if (mementoConfig.consolidationScoreEnabled && this.consolidationScoreWorker) {
-            // 시간당 증분 재계산
-            this.scheduleJob('consolidation_score_incremental', this.config.consolidationScoreIncrementalInterval, async () => { await this.runConsolidationScoreIncremental(); }, 4);
-            // 야간 전체 스윕 (하루 1회, 지정된 시간에 실행)
-            this.scheduleConsolidationScoreFullSweep();
-        }
-        // 주간 관계 추출 품질 검증 작업 스케줄링
-        this.scheduleWeeklyRelationValidation();
-        // 작업 큐 처리 시작
-        this.startJobProcessor();
-        this.log('BatchScheduler started', {
-            config: this.config,
-            startTime: this.startTime.toISOString()
-        });
-    }
-    /**
-     * 스케줄러 중지
-     */
-    async stop() {
-        if (!this.isRunning) {
-            return;
-        }
-        this.log('Stopping BatchScheduler...');
-        this.isRunning = false;
-        // 모든 인터벌 정리
-        for (const [name, interval] of this.intervals) {
-            clearInterval(interval);
-            this.log(`Stopped job: ${name}`);
-        }
-        this.intervals.clear();
-        // 작업 프로세서 인터벌 정리
-        if (this.jobProcessorInterval) {
-            clearInterval(this.jobProcessorInterval);
-            this.jobProcessorInterval = null;
-        }
-        // 실행 중인 작업 완료 대기
-        await this.waitForRunningJobs();
-        this.log('BatchScheduler stopped', {
-            uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0
-        });
-    }
-    /**
-     * 설정 검증
-     */
-    validateConfig() {
-        if (this.config.cleanupInterval < 60000) {
-            throw new Error('cleanupInterval must be at least 1 minute');
-        }
-        if (this.config.monitoringInterval < 10000) {
-            throw new Error('monitoringInterval must be at least 10 seconds');
-        }
-        if (this.config.maxBatchSize < 1) {
-            throw new Error('maxBatchSize must be at least 1');
-        }
-        if (this.config.maxConcurrentJobs < 1) {
-            throw new Error('maxConcurrentJobs must be at least 1');
-        }
-        if (this.config.jobTimeout < 1000) {
-            throw new Error('jobTimeout must be at least 1 second');
-        }
-    }
-    /**
-     * 작업 스케줄링
-     */
-    scheduleJob(name, interval, job, priority) {
-        const wrappedJob = async () => {
-            if (this.runningJobs.has(name)) {
-                this.log(`Job ${name} is already running, skipping`, { level: 'warn' });
-                return;
-            }
-            this.runningJobs.add(name);
-            const startTime = Date.now();
-            let retryCount = 0;
-            const executeWithRetry = async () => {
-                try {
-                    await this.executeWithTimeout(job, this.config.jobTimeout);
-                    this.lastExecution.set(name, new Date());
-                    this.totalExecutions.set(name, (this.totalExecutions.get(name) || 0) + 1);
-                    // 성공시 에러 카운트 리셋
-                    this.errorCount.set(name, 0);
-                    this.log(`Job ${name} completed successfully`, {
-                        duration: Date.now() - startTime,
-                        totalExecutions: this.totalExecutions.get(name),
-                        retryCount
-                    });
-                }
-                catch (error) {
-                    retryCount++;
-                    const totalErrorCount = (this.errorCount.get(name) || 0) + 1;
-                    this.errorCount.set(name, totalErrorCount);
-                    const errorInfo = {
-                        error: error instanceof Error ? error.message : String(error),
-                        stack: error instanceof Error ? error.stack : undefined,
-                        errorCount: totalErrorCount,
-                        retryCount,
-                        duration: Date.now() - startTime
-                    };
-                    this.log(`Job ${name} failed`, errorInfo, 'error');
-                    // 재시도 로직
-                    if (retryCount <= this.config.retryAttempts) {
-                        const retryDelay = this.config.retryDelay * Math.pow(2, retryCount - 1); // 지수 백오프
-                        this.log(`Retrying job ${name} in ${retryDelay}ms`, {
-                            attempt: retryCount,
-                            totalAttempts: this.config.retryAttempts,
-                            nextRetryDelay: retryDelay
-                        });
-                        setTimeout(() => {
-                            if (this.isRunning) { // 스케줄러가 여전히 실행 중인지 확인
-                                this.jobQueue.push({ name, job, priority });
-                            }
-                        }, retryDelay);
-                    }
-                    else {
-                        this.log(`Job ${name} failed permanently after ${retryCount} attempts`, {
-                            totalErrorCount,
-                            finalError: errorInfo
-                        }, 'error');
-                        // 심각한 에러의 경우 스케줄러 상태 확인
-                        if (totalErrorCount > this.config.retryAttempts * 2) {
-                            this.log(`Job ${name} has too many consecutive failures, checking scheduler health`, { level: 'warn' });
-                            await this.checkSchedulerHealth();
-                        }
-                    }
-                }
-            };
-            // 실행
-            executeWithRetry().finally(() => {
-                this.runningJobs.delete(name);
-            });
-        };
-        // 즉시 한 번 실행
-        wrappedJob();
-        // 주기적 실행
-        const intervalId = setInterval(wrappedJob, interval);
-        this.intervals.set(name, intervalId);
-    }
-    /**
-     * 작업 큐 처리기 시작
-     */
-    startJobProcessor() {
-        const processQueue = async () => {
-            if (this.jobQueue.length === 0 || this.runningJobs.size >= this.config.maxConcurrentJobs) {
-                return;
-            }
-            // 우선순위 순으로 정렬
-            this.jobQueue.sort((a, b) => a.priority - b.priority);
-            const nextJob = this.jobQueue.shift();
-            if (nextJob) {
-                await nextJob.job();
-            }
-        };
-        // 큐 처리 인터벌 (ID 저장)
-        this.jobProcessorInterval = setInterval(processQueue, 100);
-    }
-    /**
-     * 타임아웃과 함께 작업 실행
-     */
-    async executeWithTimeout(promise, timeout) {
-        return Promise.race([
-            promise(),
-            new Promise((_, reject) => {
-                setTimeout(() => reject(new Error(`Job timeout after ${timeout}ms`)), timeout);
-            })
-        ]);
-    }
-    /**
-     * 실행 중인 작업 완료 대기
-     */
-    async waitForRunningJobs() {
-        const maxWaitTime = 30000; // 30초
-        const startTime = Date.now();
-        while (this.runningJobs.size > 0 && (Date.now() - startTime) < maxWaitTime) {
-            await new Promise(resolve => setTimeout(resolve, 100));
-        }
-        if (this.runningJobs.size > 0) {
-            this.log(`Warning: ${this.runningJobs.size} jobs still running after timeout`, { level: 'warn' });
-        }
-    }
-    /**
-     * 메모리 정리 작업 실행
-     */
-    async runMemoryCleanup() {
-        const startTime = new Date();
-        const result = {
-            jobType: 'memory_cleanup',
-            startTime,
-            endTime: new Date(),
-            duration: 0,
-            success: false,
-            processed: 0,
-            errors: [],
-            warnings: []
-        };
-        try {
-            if (!this.db) {
-                throw new Error('Database not initialized');
-            }
-            this.log('Starting memory cleanup job');
-            // 망각 정책 서비스로 메모리 정리 실행
-            const cleanupResult = await this.forgettingService.executeMemoryCleanup(this.db);
-            result.success = true;
-            result.processed = cleanupResult.totalProcessed;
-            result.details = cleanupResult;
-            if (cleanupResult.softDeleted.length > 0) {
-                result.warnings.push(`${cleanupResult.softDeleted.length} memories soft deleted`);
-            }
-            if (cleanupResult.hardDeleted.length > 0) {
-                result.warnings.push(`${cleanupResult.hardDeleted.length} memories hard deleted`);
-            }
-            this.log('Memory cleanup completed', {
-                processed: cleanupResult.totalProcessed,
-                softDeleted: cleanupResult.softDeleted.length,
-                hardDeleted: cleanupResult.hardDeleted.length,
-                reviewed: cleanupResult.reviewed.length
-            });
-        }
-        catch (error) {
-            result.errors.push(error instanceof Error ? error.message : String(error));
-            this.log('Memory cleanup failed:', error, 'error');
-        }
-        finally {
-            result.endTime = new Date();
-            result.duration = result.endTime.getTime() - result.startTime.getTime();
-        }
-        return result;
-    }
-    /**
-     * 모니터링 작업 실행
-     */
-    async runMonitoring() {
-        const startTime = new Date();
-        const result = {
-            jobType: 'monitoring',
-            startTime,
-            endTime: new Date(),
-            duration: 0,
-            success: false,
-            processed: 0,
-            errors: [],
-            warnings: []
-        };
-        try {
-            if (!this.db) {
-                throw new Error('Database not initialized');
-            }
-            // 성능 모니터로 지표 수집
-            const metrics = await this.performanceMonitor.collectMetrics();
-            // 데이터베이스 상태 확인
-            const stats = await this.getDatabaseStats();
-            // 활성 알림 확인
-            const alerts = this.performanceMonitor.getActiveAlerts();
-            result.success = true;
-            result.processed = 1;
-            result.details = {
-                metrics,
-                stats,
-                alerts: {
-                    count: alerts.length,
-                    critical: alerts.filter((a) => a.severity === 'critical').length,
-                    warning: alerts.filter((a) => a.severity === 'warning').length
-                }
-            };
-            // 경고 처리
-            if (alerts.length > 0) {
-                result.warnings.push(`${alerts.length} active alerts`);
-            }
-            this.log('Monitoring completed', {
-                metrics: {
-                    memoryUsage: `${((metrics.memory.heapUsed / metrics.memory.heapTotal) * 100).toFixed(1)}%`,
-                    dbSize: `${(metrics.database.size / (1024 * 1024)).toFixed(1)}MB`,
-                    queryTime: `${metrics.database.queryTime}ms`
-                },
-                alerts: alerts.length
-            });
-        }
-        catch (error) {
-            result.errors.push(error instanceof Error ? error.message : String(error));
-            this.log('Monitoring failed:', error, 'error');
-        }
-        finally {
-            result.endTime = new Date();
-            result.duration = result.endTime.getTime() - result.startTime.getTime();
-        }
-        return result;
-    }
-    /**
-     * 헬스체크 작업 실행
-     */
-    async runHealthCheck() {
-        const startTime = new Date();
-        const result = {
-            jobType: 'healthcheck',
-            startTime,
-            endTime: new Date(),
-            duration: 0,
-            success: false,
-            processed: 0,
-            errors: [],
-            warnings: []
-        };
-        try {
-            if (!this.db) {
-                throw new Error('Database not initialized');
-            }
-            // 데이터베이스 연결 확인
-            await this.db.prepare('SELECT 1').get();
-            // 메모리 사용량 확인
-            const memUsage = process.memoryUsage();
-            const memUsagePercent = (memUsage.heapUsed / memUsage.heapTotal) * 100;
-            if (memUsagePercent > 90) {
-                result.warnings.push(`High memory usage: ${memUsagePercent.toFixed(1)}%`);
-            }
-            // 실행 중인 작업 수 확인
-            if (this.runningJobs.size > this.config.maxConcurrentJobs * 0.8) {
-                result.warnings.push(`High job concurrency: ${this.runningJobs.size}/${this.config.maxConcurrentJobs}`);
-            }
-            result.success = true;
-            result.processed = 1;
-            result.details = {
-                memoryUsage: memUsagePercent,
-                runningJobs: this.runningJobs.size,
-                uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0
-            };
-        }
-        catch (error) {
-            result.errors.push(error instanceof Error ? error.message : String(error));
-            this.log('Health check failed:', error, 'error');
-        }
-        finally {
-            result.endTime = new Date();
-            result.duration = result.endTime.getTime() - result.startTime.getTime();
-        }
-        return result;
-    }
-    /**
-     * Consolidation Score 증분 재계산 작업 실행
-     */
-    async runConsolidationScoreIncremental() {
-        const startTime = new Date();
-        const result = {
-            jobType: 'consolidation_score_incremental',
-            startTime,
-            endTime: new Date(),
-            duration: 0,
-            success: false,
-            processed: 0,
-            errors: [],
-            warnings: []
-        };
-        try {
-            if (!this.db) {
-                throw new Error('Database not initialized');
-            }
-            if (!this.consolidationScoreWorker) {
-                throw new Error('ConsolidationScoreWorker not initialized');
-            }
-            this.log('Starting consolidation score incremental recalculation');
-            const recalculationResult = await this.consolidationScoreWorker.runIncrementalRecalculation(this.db);
-            result.success = recalculationResult.success;
-            result.processed = recalculationResult.processed;
-            result.details = recalculationResult;
-            if (recalculationResult.errors.length > 0) {
-                result.errors.push(...recalculationResult.errors);
-            }
-            if (recalculationResult.warnings.length > 0) {
-                result.warnings.push(...recalculationResult.warnings);
-            }
-            this.log('Consolidation score incremental recalculation completed', {
-                processed: recalculationResult.processed,
-                updated: recalculationResult.updated,
-                skipped: recalculationResult.skipped,
-                errors: recalculationResult.errors.length
-            });
-        }
-        catch (error) {
-            result.errors.push(error instanceof Error ? error.message : String(error));
-            this.log('Consolidation score incremental recalculation failed:', error, 'error');
-        }
-        finally {
-            result.endTime = new Date();
-            result.duration = result.endTime.getTime() - result.startTime.getTime();
-        }
-        return result;
-    }
-    /**
-     * Consolidation Score 전체 스윕 작업 스케줄링
-     * 지정된 시간에 하루 1회 실행
-     */
-    scheduleConsolidationScoreFullSweep() {
-        const checkAndRun = async () => {
-            const now = new Date();
-            const currentHour = now.getHours();
-            // 지정된 시간에 실행
-            if (currentHour === this.config.consolidationScoreFullSweepHour) {
-                // 이미 오늘 실행했는지 확인 (lastExecution 체크)
-                const lastExecution = this.lastExecution.get('consolidation_score_full_sweep');
-                const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-                if (!lastExecution || lastExecution < today) {
-                    await this.runConsolidationScoreFullSweep();
-                }
-            }
-        };
-        // 매 시간마다 체크 (config 기반 간격 사용)
-        const checkInterval = 60 * 60 * 1000; // 1시간마다 체크
-        const intervalId = setInterval(checkAndRun, checkInterval);
-        // intervals Map에 저장하여 stop()에서 정리 가능하도록 함
-        this.intervals.set('consolidation_score_full_sweep', intervalId);
-        // 즉시 한 번 체크 (현재 시간이 지정된 시간이면 실행)
-        checkAndRun();
-    }
-    /**
-     * 주간 관계 추출 품질 검증 작업 스케줄링
-     */
-    scheduleWeeklyRelationValidation() {
-        const checkAndRun = async () => {
-            const now = new Date();
-            const currentDayOfWeek = now.getDay(); // 0=일요일, 6=토요일
-            const currentHour = now.getHours();
-            // 지정된 요일과 시간에 실행
-            if (currentDayOfWeek === this.config.relationValidationDayOfWeek &&
-                currentHour === this.config.relationValidationHour) {
-                // 이미 오늘 실행했는지 확인 (lastExecution 체크)
-                const lastExecution = this.lastExecution.get('weekly_relation_validation');
-                const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-                if (!lastExecution || lastExecution < today) {
-                    await this.runWeeklyRelationValidation();
-                }
-            }
-        };
-        // 매 시간마다 체크
-        const checkInterval = 60 * 60 * 1000; // 1시간마다 체크
-        const intervalId = setInterval(checkAndRun, checkInterval);
-        this.intervals.set('weekly_relation_validation', intervalId);
-        // 즉시 한 번 체크 (시작 시점이 실행 시간이면 바로 실행)
-        checkAndRun();
-    }
-    /**
-     * 주간 관계 추출 품질 검증 실행
-     */
-    async runWeeklyRelationValidation() {
-        const startTime = new Date();
-        const result = {
-            jobType: 'weekly_relation_validation',
-            startTime,
-            endTime: new Date(),
-            duration: 0,
-            success: false,
-            processed: 0,
-            errors: [],
-            warnings: []
-        };
-        try {
-            this.log('Starting weekly relation validation...');
-            // 주간 검증 스크립트 실행
-            const scriptPath = join(process.cwd(), 'scripts', 'weekly-relation-validation.ts');
-            const scriptArgs = ['--method', 'hybrid', '--allow-soft-fail'];
-            const childProcess = spawn('npx', ['tsx', scriptPath, ...scriptArgs], {
-                cwd: process.cwd(),
-                stdio: ['ignore', 'pipe', 'pipe'],
-                env: { ...process.env }
-            });
-            let stdout = '';
-            let stderr = '';
-            childProcess.stdout?.on('data', (data) => {
-                stdout += data.toString();
-            });
-            childProcess.stderr?.on('data', (data) => {
-                stderr += data.toString();
-            });
-            await new Promise((resolve, reject) => {
-                childProcess.on('close', (code) => {
-                    if (code === 0) {
-                        resolve();
-                    }
-                    else {
-                        reject(new Error(`Script exited with code ${code}\n${stderr}`));
-                    }
-                });
-                childProcess.on('error', (error) => {
-                    reject(error);
-                });
-            });
-            result.success = true;
-            result.endTime = new Date();
-            result.duration = result.endTime.getTime() - startTime.getTime();
-            result.processed = 1;
-            this.log('Weekly relation validation completed successfully', {
-                duration: result.duration,
-                stdout: stdout.substring(0, 500) // 처음 500자만 로그
-            });
-        }
-        catch (error) {
-            result.endTime = new Date();
-            result.duration = result.endTime.getTime() - startTime.getTime();
-            result.errors.push(error instanceof Error ? error.message : String(error));
-            this.log('Weekly relation validation failed', {
-                error: error instanceof Error ? error.message : String(error),
-                duration: result.duration
-            }, 'error');
-        }
-        return result;
-    }
-    /**
-     * Consolidation Score 전체 스윕 작업 실행
-     */
-    async runConsolidationScoreFullSweep() {
-        const startTime = new Date();
-        const result = {
-            jobType: 'consolidation_score_full_sweep',
-            startTime,
-            endTime: new Date(),
-            duration: 0,
-            success: false,
-            processed: 0,
-            errors: [],
-            warnings: []
-        };
-        try {
-            if (!this.db) {
-                throw new Error('Database not initialized');
-            }
-            if (!this.consolidationScoreWorker) {
-                throw new Error('ConsolidationScoreWorker not initialized');
-            }
-            this.log('Starting consolidation score full sweep recalculation');
-            const recalculationResult = await this.consolidationScoreWorker.runFullSweep(this.db);
-            result.success = recalculationResult.success;
-            result.processed = recalculationResult.processed;
-            result.details = recalculationResult;
-            if (recalculationResult.errors.length > 0) {
-                result.errors.push(...recalculationResult.errors);
-            }
-            if (recalculationResult.warnings.length > 0) {
-                result.warnings.push(...recalculationResult.warnings);
-            }
-            this.log('Consolidation score full sweep recalculation completed', {
-                processed: recalculationResult.processed,
-                updated: recalculationResult.updated,
-                skipped: recalculationResult.skipped,
-                errors: recalculationResult.errors.length,
-                duration: recalculationResult.duration
-            });
-        }
-        catch (error) {
-            result.errors.push(error instanceof Error ? error.message : String(error));
-            this.log('Consolidation score full sweep recalculation failed:', error, 'error');
-        }
-        finally {
-            result.endTime = new Date();
-            result.duration = result.endTime.getTime() - result.startTime.getTime();
-        }
-        return result;
-    }
-    /**
-     * 데이터베이스 통계 수집
-     */
-    async getDatabaseStats() {
-        if (!this.db)
-            return {};
-        try {
-            const stats = this.db.prepare(`
-        SELECT 
-          type,
-          COUNT(*) as count,
-          COUNT(CASE WHEN pinned = TRUE THEN 1 END) as pinned_count,
-          COUNT(CASE WHEN created_at < datetime('now', '-30 days') THEN 1 END) as old_count,
-          AVG(importance) as avg_importance
-        FROM memory_item 
-        GROUP BY type
-      `).all();
-            const totalMemories = this.db.prepare('SELECT COUNT(*) as count FROM memory_item').get();
-            const dbSize = this.db.prepare('PRAGMA page_count').get();
-            const pageSize = this.db.prepare('PRAGMA page_size').get();
-            return {
-                memoryStats: stats,
-                totalMemories: totalMemories.count,
-                estimatedSize: dbSize.page_count * pageSize.page_size
-            };
-        }
-        catch (error) {
-            this.log('Failed to collect database stats:', error, 'warn');
-            return {};
-        }
-    }
-    /**
-     * 로깅
-     */
-    log(message, data, level = 'info') {
-        if (!this.config.enableLogging)
-            return;
-        // stdio 모드 감지
-        const isStdioMode = process.stdin.isTTY === false && process.stdout.isTTY === false;
-        const timestamp = new Date().toISOString();
-        const logEntry = {
-            timestamp,
-            service: 'BatchScheduler',
-            level,
-            message,
-            data,
-            uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0,
-            activeJobs: this.runningJobs.size,
-            queueSize: this.jobQueue.length
-        };
-        const logMessage = `[${timestamp}] [BatchScheduler] [${level.toUpperCase()}] ${message}`;
-        // 구조화된 로그 출력
-        const logData = data ? JSON.stringify(data, null, 2) : '';
-        const contextInfo = `[Uptime: ${this.formatUptime(logEntry.uptime)}, Active: ${logEntry.activeJobs}, Queue: ${logEntry.queueSize}]`;
-        if (isStdioMode) {
-            // stdio 모드: stderr로 출력
-            const fullMessage = `${logMessage} ${contextInfo}${logData ? '\n' + logData : ''}\n`;
-            process.stderr.write(fullMessage);
-            // 에러 로그는 파일에도 저장
-            if (level === 'error') {
-                this.logToFile(logEntry);
-            }
-        }
-        else {
-            // 일반 모드: console 사용
-            switch (level) {
-                case 'error':
-                    console.error(logMessage, contextInfo, logData);
-                    this.logToFile(logEntry);
-                    break;
-                case 'warn':
-                    console.warn(logMessage, contextInfo, logData);
-                    break;
-                default:
-                    console.log(logMessage, contextInfo, logData);
-            }
-        }
-    }
-    /**
-     * 파일 로깅 (에러 로그)
-     */
-    logToFile(logEntry) {
-        try {
-            const logDir = path.join(process.cwd(), 'logs');
-            // 로그 디렉토리 생성
-            if (!fs.existsSync(logDir)) {
-                fs.mkdirSync(logDir, { recursive: true });
-            }
-            const logFile = path.join(logDir, 'batch-scheduler.log');
-            const logLine = JSON.stringify(logEntry) + '\n';
-            fs.appendFileSync(logFile, logLine);
-        }
-        catch (error) {
-            // 파일 로깅 실패는 무시
-            console.warn('Failed to write to log file:', error);
-        }
-    }
-    /**
-     * 밀리초를 사람이 읽기 쉬운 형태로 변환
-     * @param milliseconds 밀리초
-     * @returns 포맷된 시간 문자열 (예: "2h 30m 15s", "45s", "1d 3h")
-     */
-    formatUptime(milliseconds) {
-        const seconds = Math.floor(milliseconds / 1000);
-        const minutes = Math.floor(seconds / 60);
-        const hours = Math.floor(minutes / 60);
-        const days = Math.floor(hours / 24);
-        // 일 단위가 있으면 일로 표시
-        if (days > 0) {
-            const remainingHours = hours % 24;
-            return remainingHours > 0 ? `${days}d ${remainingHours}h` : `${days}d`;
-        }
-        // 시간 단위가 있으면 시간으로 표시
-        if (hours > 0) {
-            const remainingMinutes = minutes % 60;
-            return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
-        }
-        // 분 단위가 있으면 분으로 표시
-        if (minutes > 0) {
-            const remainingSeconds = seconds % 60;
-            return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
-        }
-        // 초 단위만 있으면 초로 표시
-        return `${seconds}s`;
-    }
-    /**
-     * 수동으로 작업 실행
-     */
-    async runJob(jobType) {
-        switch (jobType) {
-            case 'cleanup':
-                return await this.runMemoryCleanup();
-            case 'monitoring':
-                return await this.runMonitoring();
-            case 'healthcheck':
-                return await this.runHealthCheck();
-            default:
-                throw new Error(`Unknown job type: ${jobType}`);
-        }
-    }
-    /**
-     * 스케줄러 상태 확인
-     */
-    getStatus() {
-        return {
-            isRunning: this.isRunning,
-            activeJobs: Array.from(this.intervals.keys()),
-            lastExecution: new Map(this.lastExecution),
-            totalExecutions: new Map(this.totalExecutions),
-            errorCount: new Map(this.errorCount),
-            uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0,
-            config: { ...this.config }
-        };
-    }
-    /**
-     * 설정 업데이트
-     */
-    updateConfig(newConfig) {
-        this.config = { ...this.config, ...newConfig };
-        this.validateConfig();
-        this.log('Configuration updated', { config: this.config });
-    }
-    /**
-     * 특정 작업 중지
-     */
-    stopJob(jobName) {
-        const interval = this.intervals.get(jobName);
-        if (interval) {
-            clearInterval(interval);
-            this.intervals.delete(jobName);
-            this.log(`Stopped job: ${jobName}`);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * 특정 작업 재시작
-     */
-    restartJob(jobName) {
-        // 작업 재시작 로직 (stopJob을 호출하지 않음)
-        if (jobName === 'cleanup') {
-            this.scheduleJob('cleanup', this.config.cleanupInterval, async () => { await this.runMemoryCleanup(); }, 1);
-        }
-        else if (jobName === 'monitoring') {
-            this.scheduleJob('monitoring', this.config.monitoringInterval, async () => { await this.runMonitoring(); }, 2);
-        }
-        else if (jobName === 'healthcheck') {
-            this.scheduleJob('healthcheck', this.config.healthCheckInterval, async () => { await this.runHealthCheck(); }, 3);
-        }
-        else {
-            this.log(`Unknown job type for restart: ${jobName}`);
-            return false;
-        }
-        this.log(`Restarted job: ${jobName}`);
-        return true;
-    }
-    /**
-     * 스케줄러 헬스체크
-     */
-    async checkSchedulerHealth() {
-        try {
-            this.log('Performing scheduler health check...');
-            // 데이터베이스 연결 확인
-            if (this.db) {
-                await this.db.prepare('SELECT 1').get();
-            }
-            // 메모리 사용량 확인
-            const memUsage = process.memoryUsage();
-            const memUsagePercent = (memUsage.heapUsed / memUsage.heapTotal) * 100;
-            if (memUsagePercent > 90) {
-                this.log(`High memory usage detected: ${memUsagePercent.toFixed(1)}%`, { level: 'warn' });
-                // 메모리 정리 시도
-                if (global.gc) {
-                    global.gc();
-                    this.log('Garbage collection triggered');
-                }
-            }
-            // 실행 중인 작업 수 확인
-            if (this.runningJobs.size > this.config.maxConcurrentJobs) {
-                this.log(`Too many running jobs: ${this.runningJobs.size}/${this.config.maxConcurrentJobs}`, { level: 'warn' });
-            }
-            // 큐 크기 확인
-            if (this.jobQueue.length > 100) {
-                this.log(`Large job queue: ${this.jobQueue.length} items`, { level: 'warn' });
-            }
-            this.log('Scheduler health check completed', {
-                memoryUsage: memUsagePercent,
-                runningJobs: this.runningJobs.size,
-                queueSize: this.jobQueue.length,
-                uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0
-            });
-        }
-        catch (error) {
-            this.log('Scheduler health check failed', { error: error instanceof Error ? error.message : String(error) }, 'error');
-        }
-    }
-    /**
-     * 스케줄러 통계 조회
-     */
-    getDetailedStats() {
-        const memUsage = process.memoryUsage();
-        const memUsagePercent = (memUsage.heapUsed / memUsage.heapTotal) * 100;
-        const totalExecutions = Array.from(this.totalExecutions.values()).reduce((sum, count) => sum + count, 0);
-        const totalErrors = Array.from(this.errorCount.values()).reduce((sum, count) => sum + count, 0);
-        const errorRate = totalExecutions > 0 ? totalErrors / totalExecutions : 0;
-        const jobs = Array.from(this.intervals.keys()).map(name => ({
-            name,
-            lastExecution: this.lastExecution.get(name) || null,
-            totalExecutions: this.totalExecutions.get(name) || 0,
-            errorCount: this.errorCount.get(name) || 0,
-            errorRate: (this.totalExecutions.get(name) || 0) > 0 ? (this.errorCount.get(name) || 0) / (this.totalExecutions.get(name) || 1) : 0,
-            isRunning: this.runningJobs.has(name)
-        }));
-        return {
-            status: this.getStatus(),
-            health: {
-                memoryUsage: memUsagePercent,
-                runningJobs: this.runningJobs.size,
-                queueSize: this.jobQueue.length,
-                errorRate,
-                uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0
-            },
-            jobs
-        };
-    }
-}
-// 싱글톤 인스턴스
-let schedulerInstance = null;
-export function getBatchScheduler() {
-    if (!schedulerInstance) {
-        schedulerInstance = new BatchScheduler();
-    }
-    return schedulerInstance;
-}
-export function createBatchScheduler(config) {
-    return new BatchScheduler(config);
-}
-export function resetBatchScheduler() {
-    schedulerInstance = null;
-}
-//# sourceMappingURL=batch-scheduler.js.map