memento-mcp-server 1.16.1 → 1.16.2-a

package/scripts/count-console-logs.ts

@@ -0,0 +1,451 @@
+#!/usr/bin/env node
+/**
+ * console.log 개수 측정 스크립트
+ * 
+ * PRD 0017: 코드 품질 개선 - 로깅 일원화
+ * 
+ * 사용법:
+ *   tsx scripts/count-console-logs.ts
+ *   tsx scripts/count-console-logs.ts --ci
+ *   tsx scripts/count-console-logs.ts --core-only
+ *   tsx scripts/count-console-logs.ts --directory src/
+ * 
+ * 목표:
+ *   - 핵심 모듈 console.log 0개
+ *   - 전체 console.log 단계적 감소
+ *   - CI/CD 통합 가능
+ */
+
+import { readFileSync } from 'fs';
+import { readdir } from 'fs/promises';
+import { join, relative } from 'path';
+
+/**
+ * CLI 옵션
+ */
+interface CliOptions {
+  ci?: boolean;
+  coreOnly?: boolean;
+  directory?: string;
+  exclude?: string[];
+  target?: number;
+  allowSoftFail?: boolean;
+}
+
+/**
+ * console.* 발견 위치
+ */
+interface ConsoleLogLocation {
+  file: string;
+  line: number;
+  column: number;
+  method: string; // log, error, warn, info, debug
+  context: string;
+}
+
+/**
+ * 측정 결과
+ */
+interface CountResult {
+  total: number;
+  coreTotal: number;
+  locations: ConsoleLogLocation[];
+  byFile: Map<string, number>;
+  byMethod: Map<string, number>;
+}
+
+/**
+ * 명령줄 인자 파싱
+ */
+function parseArgs(): CliOptions {
+  const args = process.argv.slice(2);
+  const options: CliOptions = {
+    exclude: ['**/node_modules/**', '**/dist/**', '**/*.d.ts']
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--ci') {
+      options.ci = true;
+    } else if (arg === '--core-only') {
+      options.coreOnly = true;
+    } else if (arg === '--directory' && args[i + 1]) {
+      options.directory = args[i + 1];
+      i++;
+    } else if (arg === '--exclude' && args[i + 1]) {
+      if (!options.exclude) {
+        options.exclude = [];
+      }
+      options.exclude.push(args[i + 1]);
+      i++;
+    } else if (arg === '--target' && args[i + 1]) {
+      options.target = parseInt(args[i + 1], 10);
+      i++;
+    } else if (arg === '--allow-soft-fail') {
+      options.allowSoftFail = true;
+    } else if (arg === '--help' || arg === '-h') {
+      printHelp();
+      process.exit(0);
+    }
+  }
+
+  return options;
+}
+
+/**
+ * 도움말 출력
+ */
+function printHelp(): void {
+  console.log(`
+console.log 개수 측정 스크립트
+
+사용법:
+  tsx scripts/count-console-logs.ts [options]
+
+옵션:
+  --ci                    CI 모드 (실패 시 exit code 1 반환)
+  --core-only             핵심 모듈만 검사 (src/server/, src/services/)
+  --directory <path>      검사할 디렉토리 (기본값: src/)
+  --exclude <pattern>     제외할 파일 패턴 (여러 번 사용 가능)
+  --target <number>       목표 개수 (기본값: 핵심 모듈 0개, 전체 200개)
+  --allow-soft-fail       CI 모드에서 경고만 출력하고 통과
+  --help, -h              도움말 출력
+
+예제:
+  tsx scripts/count-console-logs.ts
+  tsx scripts/count-console-logs.ts --ci
+  tsx scripts/count-console-logs.ts --core-only
+  tsx scripts/count-console-logs.ts --directory src/ --exclude "**/*.spec.ts"
+`);
+}
+
+/**
+ * 핵심 모듈인지 확인
+ */
+function isCoreModule(filePath: string): boolean {
+  return filePath.includes('src/server/') || filePath.includes('src/services/');
+}
+
+/**
+ * 테스트 파일인지 확인
+ */
+function isTestFile(filePath: string): boolean {
+  return filePath.endsWith('.spec.ts') || 
+         filePath.includes('test-') || 
+         filePath.includes('/test/') ||
+         filePath.includes('/__tests__/');
+}
+
+/**
+ * CLI 스크립트인지 확인
+ */
+function isCliScript(filePath: string): boolean {
+  return filePath.includes('scripts/');
+}
+
+/**
+ * 패턴 매칭
+ */
+function matchesPattern(path: string, pattern: string): boolean {
+  if (pattern.includes('**/node_modules/**')) {
+    return path.includes('node_modules');
+  }
+  if (pattern.includes('**/dist/**')) {
+    return path.includes('dist');
+  }
+  if (pattern.includes('**/*.spec.ts')) {
+    return path.endsWith('.spec.ts');
+  }
+  if (pattern.includes('**/*.d.ts')) {
+    return path.endsWith('.d.ts');
+  }
+  return false;
+}
+
+/**
+ * 파일이 제외 패턴에 해당하는지 확인
+ */
+function shouldExclude(filePath: string, exclude: string[]): boolean {
+  for (const pattern of exclude) {
+    if (matchesPattern(filePath, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * 파일 검색 (재귀적)
+ */
+async function findFiles(directory: string, exclude: string[]): Promise<string[]> {
+  const files: string[] = [];
+  const absoluteDir = join(process.cwd(), directory);
+
+  async function walkDir(dir: string): Promise<void> {
+    try {
+      const { readdir } = await import('fs/promises');
+      const entries = await readdir(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        
+        if (shouldExclude(fullPath, exclude)) {
+          continue;
+        }
+        
+        if (entry.isDirectory()) {
+          await walkDir(fullPath);
+        } else if (entry.isFile() && entry.name.endsWith('.ts')) {
+          files.push(fullPath);
+        }
+      }
+    } catch (error) {
+      // 디렉토리 읽기 실패 시 무시
+    }
+  }
+
+  await walkDir(absoluteDir);
+  return files;
+}
+
+/**
+ * 파일에서 console.* 찾기
+ */
+function findConsoleLogs(filePath: string): ConsoleLogLocation[] {
+  const locations: ConsoleLogLocation[] = [];
+  
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    
+    // console.log, console.error, console.warn, console.info, console.debug 패턴
+    const consolePattern = /console\.(log|error|warn|info|debug)\s*\(/g;
+    
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+      const line = lines[lineIndex];
+      
+      // 주석 제외
+      if (line.trim().startsWith('//')) {
+        continue;
+      }
+      
+      // 문자열 내부 제외 (간단한 휴리스틱)
+      const inString = (line.match(/['"]/g) || []).length % 2 === 1;
+      if (inString) {
+        continue;
+      }
+      
+      // console.* 패턴 검색
+      let match;
+      while ((match = consolePattern.exec(line)) !== null) {
+        locations.push({
+          file: filePath,
+          line: lineIndex + 1,
+          column: match.index + 1,
+          method: match[1],
+          context: line.trim()
+        });
+      }
+    }
+  } catch (error) {
+    // 파일 읽기 실패 시 무시
+  }
+  
+  return locations;
+}
+
+/**
+ * console.log 개수 측정
+ */
+function countConsoleLogs(files: string[], coreOnly: boolean): CountResult {
+  const locations: ConsoleLogLocation[] = [];
+  const byFile = new Map<string, number>();
+  const byMethod = new Map<string, number>();
+  
+  for (const file of files) {
+    // 테스트 파일과 CLI 스크립트는 제외
+    if (isTestFile(file) || isCliScript(file)) {
+      continue;
+    }
+    
+    // 핵심 모듈만 검사하는 경우
+    if (coreOnly && !isCoreModule(file)) {
+      continue;
+    }
+    
+    const fileLocations = findConsoleLogs(file);
+    locations.push(...fileLocations);
+    
+    if (fileLocations.length > 0) {
+      byFile.set(file, fileLocations.length);
+      
+      for (const loc of fileLocations) {
+        const count = byMethod.get(loc.method) || 0;
+        byMethod.set(loc.method, count + 1);
+      }
+    }
+  }
+  
+  // 핵심 모듈 개수 계산
+  const coreLocations = locations.filter(loc => isCoreModule(loc.file));
+  
+  return {
+    total: locations.length,
+    coreTotal: coreLocations.length,
+    locations,
+    byFile,
+    byMethod
+  };
+}
+
+/**
+ * 결과 출력
+ */
+function printResults(
+  result: CountResult,
+  target: number,
+  coreTarget: number,
+  projectRoot: string,
+  coreOnly: boolean
+): void {
+  console.log('\n📊 console.log 개수 측정 결과\n');
+  
+  if (coreOnly) {
+    console.log(`핵심 모듈 console.* 개수: ${result.coreTotal}개`);
+    console.log(`목표 개수: ${coreTarget}개 이하`);
+    
+    if (result.coreTotal > coreTarget) {
+      console.log(`⚠️  목표 대비: ${result.coreTotal - coreTarget}개 초과\n`);
+    } else {
+      console.log(`✅ 목표 달성\n`);
+    }
+  } else {
+    console.log(`전체 console.* 개수: ${result.total}개`);
+    console.log(`핵심 모듈 console.* 개수: ${result.coreTotal}개`);
+    console.log(`목표 개수: 전체 ${target}개 이하, 핵심 모듈 ${coreTarget}개 이하\n`);
+    
+    if (result.coreTotal > coreTarget) {
+      console.log(`⚠️  핵심 모듈 목표 대비: ${result.coreTotal - coreTarget}개 초과`);
+    }
+    if (result.total > target) {
+      console.log(`⚠️  전체 목표 대비: ${result.total - target}개 초과`);
+    }
+    console.log('');
+  }
+  
+  // 메서드별 통계
+  if (result.byMethod.size > 0) {
+    console.log('📈 메서드별 통계:');
+    const sortedMethods = Array.from(result.byMethod.entries())
+      .sort((a, b) => b[1] - a[1]);
+    
+    for (const [method, count] of sortedMethods) {
+      console.log(`   console.${method}: ${count}개`);
+    }
+    console.log('');
+  }
+  
+  // 파일별 통계 (상위 10개)
+  if (result.byFile.size > 0) {
+    console.log('📁 파일별 console.* 개수 (상위 10개):');
+    const sortedFiles = Array.from(result.byFile.entries())
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 10);
+    
+    for (const [file, count] of sortedFiles) {
+      const relativePath = relative(projectRoot, file);
+      const isCore = isCoreModule(file);
+      const marker = isCore ? '🔴' : '  ';
+      console.log(`   ${marker} ${relativePath}: ${count}개`);
+    }
+    console.log('');
+  }
+  
+  // 핵심 모듈 파일 목록
+  if (!coreOnly && result.coreTotal > 0) {
+    const coreFiles = Array.from(result.byFile.entries())
+      .filter(([file]) => isCoreModule(file))
+      .sort((a, b) => b[1] - a[1]);
+    
+    if (coreFiles.length > 0) {
+      console.log('🔴 핵심 모듈 파일 목록:');
+      for (const [file, count] of coreFiles) {
+        const relativePath = relative(projectRoot, file);
+        console.log(`   ${relativePath}: ${count}개`);
+      }
+      console.log('');
+    }
+  }
+}
+
+/**
+ * 메인 함수
+ */
+async function main(): Promise<void> {
+  const options = parseArgs();
+  const projectRoot = process.cwd();
+  const directory = options.directory || 'src/';
+  const exclude = options.exclude || ['**/node_modules/**', '**/dist/**', '**/*.d.ts'];
+  const coreTarget = 0; // 핵심 모듈은 항상 0개 목표
+  const target = options.target || (options.coreOnly ? 0 : 200);
+
+  try {
+    // 파일 검색
+    const searchDir = options.coreOnly ? 'src/' : directory;
+    console.log(`🔍 파일 검색 중... (디렉토리: ${searchDir}${options.coreOnly ? ', 핵심 모듈만' : ''})`);
+    const files = await findFiles(searchDir, exclude);
+    
+    if (files.length === 0) {
+      console.log('⚠️  검사할 파일이 없습니다.');
+      process.exit(0);
+    }
+
+    console.log(`   발견된 파일: ${files.length}개\n`);
+
+    // console.log 개수 측정
+    console.log('🔎 console.* 검색 중...');
+    const result = countConsoleLogs(files, options.coreOnly || false);
+
+    // 결과 출력
+    printResults(result, target, coreTarget, projectRoot, options.coreOnly || false);
+
+    // CI 모드: exit code 처리
+    if (options.ci) {
+      const failed = options.coreOnly 
+        ? result.coreTotal > coreTarget
+        : result.coreTotal > coreTarget || result.total > target;
+      
+      if (failed) {
+        if (options.coreOnly) {
+          console.log(`❌ CI 실패: 핵심 모듈 console.*가 ${result.coreTotal}개로 목표(${coreTarget}개)를 초과했습니다.`);
+        } else {
+          console.log(`❌ CI 실패: 전체 ${result.total}개, 핵심 모듈 ${result.coreTotal}개로 목표를 초과했습니다.`);
+        }
+        process.exit(1);
+      } else {
+        console.log(`✅ CI 통과: 목표를 달성했습니다.`);
+        process.exit(0);
+      }
+    } else {
+      // 일반 모드: 정보만 출력
+      if (result.coreTotal > coreTarget || result.total > target) {
+        console.log('💡 팁: --ci 옵션을 사용하면 CI/CD 파이프라인에 통합할 수 있습니다.');
+      }
+    }
+  } catch (error) {
+    console.error('❌ 오류 발생:', error instanceof Error ? error.message : String(error));
+    if (error instanceof Error && error.stack) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// 스크립트 직접 실행 시
+if (import.meta.url === `file://${process.argv[1]}` || import.meta.url.endsWith(process.argv[1])) {
+  main().catch(error => {
+    console.error('❌ 치명적 오류:', error);
+    process.exit(1);
+  });
+}
+