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

package/dist/infrastructure/scheduler/batch-scheduler.js

@@ -0,0 +1,926 @@
+/**
+ * 배치 작업 스케줄러
+ * TTL 기반 메모리 정리 및 기타 주기적 작업을 자동화
+ * Memento MCP Server의 핵심 배치 처리 컴포넌트
+ */
+import { ForgettingPolicyService } from '../../domains/forgetting/services/forgetting-policy-service.js';
+import { getPerformanceMonitor } from '../../domains/monitoring/services/performance-monitor.js';
+import { DatabaseUtils } from '../../shared/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 '../../shared/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