memento-mcp-server 1.6.0 → 1.7.1

package/src/services/database-optimizer.ts

@@ -1,450 +0,0 @@
-/**
- * 데이터베이스 성능 최적화 서비스
- * 인덱스 최적화, 쿼리 분석, 성능 튜닝
- */
-
-import { DatabaseUtils } from '../utils/database.js';
-import Database from 'better-sqlite3';
-
-export interface IndexRecommendation {
-  table: string;
-  columns: string[];
-  type: 'btree' | 'fts' | 'partial';
-  priority: 'high' | 'medium' | 'low';
-  reason: string;
-  estimatedImprovement: string;
-}
-
-export interface QueryAnalysis {
-  query: string;
-  executionTime: number;
-  explainPlan: any[];
-  recommendations: string[];
-  complexity: 'simple' | 'medium' | 'complex';
-}
-
-export interface DatabaseStats {
-  tableStats: Record<string, {
-    rowCount: number;
-    size: number;
-    indexCount: number;
-    lastAnalyzed: Date;
-  }>;
-  indexStats: Record<string, {
-    name: string;
-    table: string;
-    columns: string[];
-    size: number;
-    usage: number;
-  }>;
-  queryStats: {
-    totalQueries: number;
-    averageTime: number;
-    slowQueries: QueryAnalysis[];
-  };
-}
-
-export class DatabaseOptimizer {
-  private db: Database.Database;
-  private queryHistory: Map<string, { count: number; totalTime: number; lastUsed: Date }> = new Map();
-
-  constructor(db: Database.Database) {
-    this.db = db;
-  }
-
-  /**
-   * 데이터베이스 성능 분석
-   */
-  async analyzePerformance(): Promise<DatabaseStats> {
-    const tableStats = await this.analyzeTables();
-    const indexStats = await this.analyzeIndexes();
-    const queryStats = await this.analyzeQueries();
-
-    return {
-      tableStats,
-      indexStats,
-      queryStats
-    };
-  }
-
-  /**
-   * 테이블 분석
-   */
-  private async analyzeTables(): Promise<Record<string, any>> {
-    const tables = await DatabaseUtils.all(this.db, `
-      SELECT name FROM sqlite_master 
-      WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
-    `);
-
-    const stats: Record<string, any> = {};
-
-    for (const table of tables) {
-      const tableName = table.name;
-      
-      // 행 수
-      const rowCount = await DatabaseUtils.all(this.db, `SELECT COUNT(*) as count FROM ${tableName}`);
-      
-      // 테이블 크기 (간단한 추정)
-      const size = await DatabaseUtils.all(this.db, `
-        SELECT page_count * page_size as size 
-        FROM pragma_page_count(), pragma_page_size()
-      `);
-      
-      // 인덱스 수
-      const indexCount = await DatabaseUtils.all(this.db, `
-        SELECT COUNT(*) as count 
-        FROM sqlite_master 
-        WHERE type = 'index' AND tbl_name = '${tableName}' AND name NOT LIKE 'sqlite_%'
-      `);
-
-      stats[tableName] = {
-        rowCount: rowCount[0].count,
-        size: size[0].size,
-        indexCount: indexCount[0].count,
-        lastAnalyzed: new Date()
-      };
-    }
-
-    return stats;
-  }
-
-  /**
-   * 인덱스 분석
-   */
-  private async analyzeIndexes(): Promise<Record<string, any>> {
-    const indexes = await DatabaseUtils.all(this.db, `
-      SELECT name, tbl_name, sql 
-      FROM sqlite_master 
-      WHERE type = 'index' AND name NOT LIKE 'sqlite_%'
-    `);
-
-    const stats: Record<string, any> = {};
-
-    for (const index of indexes) {
-      // 인덱스 크기 (간단한 추정 - 인덱스는 테이블이 아니므로 페이지 정보를 직접 가져올 수 없음)
-      const size = await DatabaseUtils.all(this.db, `
-        SELECT page_count * page_size as size 
-        FROM pragma_page_count(), pragma_page_size()
-      `);
-
-      // 컬럼 추출 (간단한 파싱)
-      const columns = this.extractColumnsFromIndexSQL(index.sql);
-
-      stats[index.name] = {
-        name: index.name,
-        table: index.tbl_name,
-        columns,
-        size: size[0].size, // 전체 데이터베이스 크기로 추정
-        usage: 0 // 실제로는 SQLite 통계에서 가져와야 함
-      };
-    }
-
-    return stats;
-  }
-
-  /**
-   * 쿼리 분석
-   */
-  private async analyzeQueries(): Promise<any> {
-    const totalQueries = Array.from(this.queryHistory.values())
-      .reduce((sum, q) => sum + q.count, 0);
-    
-    const averageTime = Array.from(this.queryHistory.values())
-      .reduce((sum, q) => sum + q.totalTime, 0) / totalQueries || 0;
-
-    const slowQueries = Array.from(this.queryHistory.entries())
-      .map(([query, stats]) => ({
-        query,
-        executionTime: stats.totalTime / stats.count,
-        explainPlan: [], // 실제로는 EXPLAIN QUERY PLAN 실행
-        recommendations: this.generateQueryRecommendations(query),
-        complexity: this.assessQueryComplexity(query)
-      }))
-      .filter(q => q.executionTime > 50) // 50ms 이상
-      .sort((a, b) => b.executionTime - a.executionTime)
-      .slice(0, 10);
-
-    return {
-      totalQueries,
-      averageTime,
-      slowQueries
-    };
-  }
-
-  /**
-   * 인덱스 추천 생성
-   */
-  async generateIndexRecommendations(): Promise<IndexRecommendation[]> {
-    const recommendations: IndexRecommendation[] = [];
-    
-    // 자주 사용되는 쿼리 패턴 분석
-    const commonPatterns = this.analyzeQueryPatterns();
-    
-    for (const pattern of commonPatterns) {
-      if (pattern.type === 'filter' && pattern.frequency > 10) {
-        recommendations.push({
-          table: pattern.table,
-          columns: pattern.columns,
-          type: 'btree',
-          priority: pattern.frequency > 50 ? 'high' : 'medium',
-          reason: `자주 사용되는 필터 조건 (${pattern.frequency}회)`,
-          estimatedImprovement: '50-80% 쿼리 성능 향상 예상'
-        });
-      }
-    }
-
-    // 복합 쿼리 최적화
-    const complexQueries = Array.from(this.queryHistory.entries())
-      .filter(([, stats]) => stats.totalTime > 1000)
-      .map(([query]) => query);
-
-    for (const query of complexQueries) {
-      const tableMatch = query.match(/FROM\s+(\w+)/i);
-      if (!tableMatch || !tableMatch[1]) continue;
-      const tableName = tableMatch[1];
-      
-      const columns = this.extractColumnsFromQuery(query);
-      if (columns.length > 1) {
-        recommendations.push({
-          table: tableName,
-          columns,
-          type: 'btree',
-          priority: 'high',
-          reason: '복합 쿼리 최적화',
-          estimatedImprovement: '30-60% 쿼리 성능 향상 예상'
-        });
-      }
-    }
-
-    return recommendations;
-  }
-
-  /**
-   * 쿼리 패턴 분석
-   */
-  private analyzeQueryPatterns(): Array<{ type: string; table: string; columns: string[]; frequency: number }> {
-    const patterns: Array<{ type: string; table: string; columns: string[]; frequency: number }> = [];
-    
-    for (const [query, stats] of this.queryHistory) {
-      // 쿼리에서 테이블명 추출
-      const tableMatch = query.match(/FROM\s+(\w+)/i);
-      if (!tableMatch || !tableMatch[1]) continue;
-      const tableName = tableMatch[1];
-      
-      if (query.includes('WHERE')) {
-        const whereClause = query.match(/WHERE\s+(.+?)(?:\s+ORDER|\s+GROUP|\s+LIMIT|$)/i);
-        if (whereClause && whereClause[1]) {
-          const conditions = whereClause[1].split('AND').map(c => c.trim());
-          for (const condition of conditions) {
-            const column = this.extractColumnFromCondition(condition);
-            if (column) {
-              const existing = patterns.find(p => p.table === tableName && p.columns.includes(column));
-              if (existing) {
-                existing.frequency += stats.count;
-              } else {
-                patterns.push({
-                  type: 'filter',
-                  table: tableName,
-                  columns: [column],
-                  frequency: stats.count
-                });
-              }
-            }
-          }
-        }
-      }
-    }
-
-    return patterns;
-  }
-
-  /**
-   * 쿼리 추천 생성
-   */
-  private generateQueryRecommendations(query: string): string[] {
-    const recommendations: string[] = [];
-
-    // SELECT * 사용 검사
-    if (query.includes('SELECT *')) {
-      recommendations.push('SELECT * 대신 필요한 컬럼만 명시하세요');
-    }
-
-    // 인덱스 힌트 검사
-    if (query.includes('ORDER BY') && !query.includes('INDEXED BY')) {
-      recommendations.push('ORDER BY 절에 인덱스 힌트를 추가하세요');
-    }
-
-    // LIKE 패턴 검사
-    if (query.includes('LIKE \'%')) {
-      recommendations.push('LIKE \'%...\' 패턴은 인덱스를 사용할 수 없습니다. FTS5를 고려하세요');
-    }
-
-    // 서브쿼리 검사
-    if (query.includes('SELECT') && (query.match(/SELECT/g) || []).length > 1) {
-      recommendations.push('서브쿼리를 JOIN으로 변경하는 것을 고려하세요');
-    }
-
-    return recommendations;
-  }
-
-  /**
-   * 쿼리 복잡도 평가
-   */
-  private assessQueryComplexity(query: string): 'simple' | 'medium' | 'complex' {
-    let complexity = 0;
-    
-    if (query.includes('JOIN')) complexity += 2;
-    if (query.includes('GROUP BY')) complexity += 1;
-    if (query.includes('ORDER BY')) complexity += 1;
-    if (query.includes('HAVING')) complexity += 1;
-    if (query.includes('UNION')) complexity += 2;
-    if (query.includes('SELECT') && (query.match(/SELECT/g) || []).length > 1) complexity += 2;
-    
-    if (complexity <= 1) return 'simple';
-    if (complexity <= 3) return 'medium';
-    return 'complex';
-  }
-
-  /**
-   * 쿼리 실행 통계 기록
-   */
-  recordQuery(query: string, executionTime: number): void {
-    const existing = this.queryHistory.get(query);
-    if (existing) {
-      existing.count++;
-      existing.totalTime += executionTime;
-      existing.lastUsed = new Date();
-    } else {
-      this.queryHistory.set(query, {
-        count: 1,
-        totalTime: executionTime,
-        lastUsed: new Date()
-      });
-    }
-  }
-
-  /**
-   * 인덱스 생성
-   */
-  async createIndex(name: string, table: string, columns: string[], unique: boolean = false): Promise<void> {
-    const uniqueKeyword = unique ? 'UNIQUE' : '';
-    const columnsStr = columns.join(', ');
-    const sql = `CREATE ${uniqueKeyword} INDEX IF NOT EXISTS ${name} ON ${table} (${columnsStr})`;
-    
-    await DatabaseUtils.run(this.db, sql);
-  }
-
-  /**
-   * 인덱스 삭제
-   */
-  async dropIndex(name: string): Promise<void> {
-    await DatabaseUtils.run(this.db, `DROP INDEX IF EXISTS ${name}`);
-  }
-
-  /**
-   * 데이터베이스 분석 실행
-   */
-  async analyzeDatabase(): Promise<void> {
-    await DatabaseUtils.run(this.db, 'ANALYZE');
-  }
-
-  /**
-   * 쿼리에서 컬럼 추출
-   */
-  private extractColumnsFromQuery(query: string): string[] {
-    const columns: string[] = [];
-    
-    // WHERE 절에서 컬럼 추출
-    const whereMatch = query.match(/WHERE\s+(.+?)(?:\s+ORDER|\s+GROUP|\s+LIMIT|$)/i);
-    if (whereMatch && whereMatch[1]) {
-      const conditions = whereMatch[1].split(/AND|OR/).map(c => c.trim());
-      for (const condition of conditions) {
-        const column = this.extractColumnFromCondition(condition);
-        if (column) columns.push(column);
-      }
-    }
-
-    // ORDER BY 절에서 컬럼 추출
-    const orderMatch = query.match(/ORDER BY\s+(.+?)(?:\s+LIMIT|$)/i);
-    if (orderMatch && orderMatch[1]) {
-      const orderColumns = orderMatch[1].split(',').map(c => c.trim().split(' ')[0]).filter((c): c is string => Boolean(c));
-      columns.push(...orderColumns);
-    }
-
-    return [...new Set(columns)]; // 중복 제거
-  }
-
-  /**
-   * 조건에서 컬럼 추출
-   */
-  private extractColumnFromCondition(condition: string): string | null {
-    const match = condition.match(/(\w+)\s*[=<>!]/);
-    return match && match[1] ? match[1] : null;
-  }
-
-  /**
-   * 인덱스 SQL에서 컬럼 추출
-   */
-  private extractColumnsFromIndexSQL(sql: string): string[] {
-    const match = sql.match(/\((.+?)\)/);
-    if (match && match[1]) {
-      return match[1].split(',').map(c => c.trim());
-    }
-    return [];
-  }
-
-  /**
-   * 성능 최적화 리포트 생성
-   */
-  async generateOptimizationReport(): Promise<string> {
-    const stats = await this.analyzePerformance();
-    const recommendations = await this.generateIndexRecommendations();
-
-    const report = `
-# 데이터베이스 성능 최적화 리포트
-생성 시간: ${new Date().toISOString()}
-
-## 테이블 통계
-${Object.entries(stats.tableStats)
-  .map(([table, stat]) => `
-### ${table}
-- 행 수: ${stat.rowCount.toLocaleString()}
-- 크기: ${(stat.size / 1024 / 1024).toFixed(2)} MB
-- 인덱스 수: ${stat.indexCount}개
-`).join('')}
-
-## 인덱스 통계
-${Object.entries(stats.indexStats)
-  .map(([name, stat]) => `
-### ${name}
-- 테이블: ${stat.table}
-- 컬럼: ${stat.columns.join(', ')}
-- 크기: ${(stat.size / 1024).toFixed(2)} KB
-`).join('')}
-
-## 쿼리 성능
-- 총 쿼리: ${stats.queryStats.totalQueries}회
-- 평균 실행 시간: ${stats.queryStats.averageTime.toFixed(2)}ms
-
-## 느린 쿼리 (상위 5개)
-${stats.queryStats.slowQueries.slice(0, 5)
-  .map((q, i) => `
-${i + 1}. **${q.complexity.toUpperCase()}** (${q.executionTime.toFixed(2)}ms)
-   \`\`\`sql
-   ${q.query}
-   \`\`\`
-   **추천사항:**
-   ${q.recommendations.map(r => `- ${r}`).join('\n   ')}
-`).join('')}
-
-## 인덱스 추천
-${recommendations.map((rec, i) => `
-${i + 1}. **${rec.priority.toUpperCase()}** - ${rec.table}.${rec.columns.join(', ')}
-   - 이유: ${rec.reason}
-   - 예상 개선: ${rec.estimatedImprovement}
-`).join('')}
-`;
-
-    return report;
-  }
-}

package/src/services/embedding-provider-factory.ts

@@ -1,173 +0,0 @@
-/**
- * 임베딩 제공자 팩토리
- * 전략 패턴을 사용하여 순환 의존성 방지
- * 
- * 클린코드 원칙:
- * - 단일 책임 원칙: 제공자 생성만 담당
- * - 의존성 역전: 인터페이스에 의존
- * - 개방-폐쇄: 새로운 제공자 추가 용이
- */
-
-import type { EmbeddingServiceInterface, EmbeddingProvider, ProviderInfo } from '../types/embedding.types.js';
-import { mementoConfig } from '../config/index.js';
-import { MiniLMEmbeddingService } from './minilm-embedding-service.js';
-import { LightweightEmbeddingService } from './lightweight-embedding-service.js';
-import { GeminiEmbeddingService } from './gemini-embedding-service.js';
-
-/**
- * 임베딩 제공자 팩토리
- * 순환 의존성을 방지하기 위해 팩토리 패턴 사용
- */
-export class EmbeddingProviderFactory {
-  private static instance: EmbeddingProviderFactory;
-  private providers: Map<EmbeddingProvider, EmbeddingServiceInterface> = new Map();
-
-  private constructor() {
-    this.initializeProviders();
-  }
-
-  /**
-   * 싱글톤 인스턴스 반환
-   */
-  static getInstance(): EmbeddingProviderFactory {
-    if (!EmbeddingProviderFactory.instance) {
-      EmbeddingProviderFactory.instance = new EmbeddingProviderFactory();
-    }
-    return EmbeddingProviderFactory.instance;
-  }
-
-  /**
-   * 제공자 초기화
-   * 클린코드: 단일 책임 원칙 - 초기화만 담당
-   */
-  private initializeProviders(): void {
-    this.providers.set('minilm', new MiniLMEmbeddingService());
-    this.providers.set('tfidf', new LightweightEmbeddingService());
-    this.providers.set('gemini', new GeminiEmbeddingService());
-    // OpenAI는 설정에 따라 동적 생성
-  }
-
-  /**
-   * 제공자 반환
-   * 클린코드: 단일 책임 원칙 - 제공자 반환만 담당
-   */
-  getProvider(provider: EmbeddingProvider): EmbeddingServiceInterface | null {
-    return this.providers.get(provider) || null;
-  }
-
-  /**
-   * 사용 가능한 제공자 목록 반환
-   * TDD: 각 제공자의 사용 가능 여부 확인
-   */
-  getAvailableProviders(): ProviderInfo[] {
-    const providerInfos: ProviderInfo[] = [];
-
-    // MiniLM
-    const minilm = this.providers.get('minilm');
-    providerInfos.push({
-      name: 'minilm',
-      available: minilm?.isAvailable() || false,
-      priority: 1,
-      cost: 'free',
-      performance: 'high'
-    });
-
-    // TF-IDF (항상 사용 가능)
-    const tfidf = this.providers.get('tfidf');
-    providerInfos.push({
-      name: 'tfidf',
-      available: tfidf?.isAvailable() || false,
-      priority: 4,
-      cost: 'free',
-      performance: 'low'
-    });
-
-    // Gemini
-    const gemini = this.providers.get('gemini');
-    providerInfos.push({
-      name: 'gemini',
-      available: gemini?.isAvailable() || false,
-      priority: 2,
-      cost: 'paid',
-      performance: 'high'
-    });
-
-    // OpenAI (동적 생성)
-    providerInfos.push({
-      name: 'openai',
-      available: this.isOpenAIAvailable(),
-      priority: 3,
-      cost: 'paid',
-      performance: 'high'
-    });
-
-    return providerInfos.sort((a, b) => a.priority - b.priority);
-  }
-
-  /**
-   * 우선순위에 따른 제공자 선택
-   * TDD: 사용 가능한 제공자 중 우선순위가 높은 것 선택
-   */
-  selectProvider(preferredProvider?: EmbeddingProvider): EmbeddingServiceInterface | null {
-    const availableProviders = this.getAvailableProviders();
-    
-    // 1. 명시적으로 요청된 제공자 우선
-    if (preferredProvider) {
-      const preferred = availableProviders.find(p => p.name === preferredProvider && p.available);
-      if (preferred) {
-        console.log(`🎯 요청된 제공자 사용: ${preferredProvider}`);
-        return this.getProvider(preferred.name);
-      }
-    }
-
-    // 2. 설정에서 기본 제공자 사용
-    const defaultProvider = mementoConfig.embeddingProvider;
-    const defaultAvailable = availableProviders.find(p => p.name === defaultProvider && p.available);
-    if (defaultAvailable) {
-      console.log(`⚙️ 설정된 기본 제공자 사용: ${defaultProvider}`);
-      return this.getProvider(defaultAvailable.name);
-    }
-
-    // 3. 사용 가능한 첫 번째 제공자 반환
-    const firstAvailable = availableProviders.find(p => p.available);
-    if (firstAvailable) {
-      console.log(`🔄 사용 가능한 첫 번째 제공자 사용: ${firstAvailable.name}`);
-      return this.getProvider(firstAvailable.name);
-    }
-
-    console.log('❌ 사용 가능한 제공자가 없습니다');
-    return null;
-  }
-
-  /**
-   * OpenAI 사용 가능 여부 확인
-   * 클린코드: 단일 책임 원칙 - OpenAI 상태 확인만 담당
-   */
-  private isOpenAIAvailable(): boolean {
-    // 환경 변수나 설정 확인
-    return process.env.OPENAI_API_KEY !== undefined;
-  }
-
-  /**
-   * 제공자 등록 (확장성)
-   * 클린코드: 개방-폐쇄 원칙 - 확장에는 열려있음
-   */
-  registerProvider(provider: EmbeddingProvider, service: EmbeddingServiceInterface): void {
-    this.providers.set(provider, service);
-  }
-
-  /**
-   * 제공자 제거
-   */
-  unregisterProvider(provider: EmbeddingProvider): boolean {
-    return this.providers.delete(provider);
-  }
-
-  /**
-   * 모든 제공자 초기화
-   */
-  reset(): void {
-    this.providers.clear();
-    this.initializeProviders();
-  }
-}