docuking-mcp 2.9.0 → 2.9.2

package/handlers/validate.js

@@ -1,544 +1,544 @@
-/**
- * DocuKing MCP - 킹밸리데이트 핸들러
- * 코드가 정책을 준수하는지 검증
- */
-
-import fs from 'fs';
-import path from 'path';
-
-/**
- * 정책 파일에서 검증 규칙 추출
- * @param {string} policyContent - 정책 파일 내용
- * @param {string} policyName - 정책 파일 이름
- * @returns {Array} 추출된 규칙 목록
- */
-function extractRulesFromPolicy(policyContent, policyName) {
-  const rules = [];
-
-  // 코드 블록 내의 규칙 패턴 추출
-  // 예: ```폴더명/``` 또는 ```파일패턴```
-  const codeBlockRegex = /```([^`]+)```/g;
-  let match;
-
-  // 폴더 구조 정책 (01_folder_structure.md)
-  if (policyName.includes('folder_structure')) {
-    // 폴더 패턴 추출: "src/components/" 같은 패턴
-    const folderPatterns = policyContent.match(/[-*]\s*`([^`]+\/)`/g);
-    if (folderPatterns) {
-      folderPatterns.forEach(p => {
-        const folder = p.match(/`([^`]+\/)`/)?.[1];
-        if (folder) {
-          rules.push({
-            type: 'folder_exists',
-            pattern: folder,
-            policy: policyName,
-          });
-        }
-      });
-    }
-
-    // 금지 패턴 추출: "금지", "하지 말 것", "사용하지 않음" 등
-    const forbiddenLines = policyContent.split('\n').filter(line =>
-      line.includes('금지') || line.includes('하지 말') || line.includes('사용하지 않')
-    );
-    forbiddenLines.forEach(line => {
-      const pattern = line.match(/`([^`]+)`/)?.[1];
-      if (pattern) {
-        rules.push({
-          type: 'forbidden_pattern',
-          pattern: pattern,
-          message: line.trim(),
-          policy: policyName,
-        });
-      }
-    });
-  }
-
-  // 명명 규칙 정책 (02_naming_convention.md)
-  if (policyName.includes('naming_convention')) {
-    // PascalCase 규칙
-    if (policyContent.includes('PascalCase')) {
-      const pascalPatterns = policyContent.match(/[-*]\s*([^:]+):\s*PascalCase/gi);
-      if (pascalPatterns) {
-        pascalPatterns.forEach(p => {
-          const target = p.match(/[-*]\s*([^:]+):/)?.[1]?.trim();
-          if (target) {
-            rules.push({
-              type: 'naming_convention',
-              convention: 'PascalCase',
-              target: target,
-              policy: policyName,
-            });
-          }
-        });
-      }
-    }
-
-    // camelCase 규칙
-    if (policyContent.includes('camelCase')) {
-      const camelPatterns = policyContent.match(/[-*]\s*([^:]+):\s*camelCase/gi);
-      if (camelPatterns) {
-        camelPatterns.forEach(p => {
-          const target = p.match(/[-*]\s*([^:]+):/)?.[1]?.trim();
-          if (target) {
-            rules.push({
-              type: 'naming_convention',
-              convention: 'camelCase',
-              target: target,
-              policy: policyName,
-            });
-          }
-        });
-      }
-    }
-
-    // snake_case 규칙
-    if (policyContent.includes('snake_case')) {
-      const snakePatterns = policyContent.match(/[-*]\s*([^:]+):\s*snake_case/gi);
-      if (snakePatterns) {
-        snakePatterns.forEach(p => {
-          const target = p.match(/[-*]\s*([^:]+):/)?.[1]?.trim();
-          if (target) {
-            rules.push({
-              type: 'naming_convention',
-              convention: 'snake_case',
-              target: target,
-              policy: policyName,
-            });
-          }
-        });
-      }
-    }
-  }
-
-  // DB 스키마 정책 (05_database_schema.md)
-  if (policyName.includes('database_schema')) {
-    // 필수 컬럼 추출
-    const requiredColumns = policyContent.match(/필수[^:]*:\s*([^\n]+)/gi);
-    if (requiredColumns) {
-      requiredColumns.forEach(line => {
-        const columns = line.match(/`([^`]+)`/g);
-        if (columns) {
-          columns.forEach(col => {
-            rules.push({
-              type: 'required_column',
-              column: col.replace(/`/g, ''),
-              policy: policyName,
-            });
-          });
-        }
-      });
-    }
-
-    // 컬럼 명명 규칙
-    if (policyContent.includes('snake_case') && policyContent.includes('컬럼')) {
-      rules.push({
-        type: 'column_naming',
-        convention: 'snake_case',
-        policy: policyName,
-      });
-    }
-  }
-
-  // API 규칙 정책 (03_api_convention.md)
-  if (policyName.includes('api_convention')) {
-    // REST 규칙 추출
-    const restRules = policyContent.match(/[-*]\s*(GET|POST|PUT|DELETE|PATCH)\s+([^\n]+)/gi);
-    if (restRules) {
-      restRules.forEach(rule => {
-        const method = rule.match(/(GET|POST|PUT|DELETE|PATCH)/i)?.[1];
-        const description = rule.replace(/[-*]\s*(GET|POST|PUT|DELETE|PATCH)/i, '').trim();
-        if (method) {
-          rules.push({
-            type: 'api_method',
-            method: method.toUpperCase(),
-            description: description,
-            policy: policyName,
-          });
-        }
-      });
-    }
-  }
-
-  return rules;
-}
-
-/**
- * 폴더 존재 여부 검증
- */
-function validateFolderExists(basePath, folderPattern) {
-  const fullPath = path.join(basePath, folderPattern.replace(/\/$/, ''));
-  if (!fs.existsSync(fullPath)) {
-    return {
-      valid: false,
-      message: `폴더가 존재하지 않음: ${folderPattern}`,
-      suggestion: `mkdir -p ${fullPath}`,
-    };
-  }
-  return { valid: true };
-}
-
-/**
- * 파일명 명명 규칙 검증
- */
-function validateNamingConvention(filePath, convention) {
-  const fileName = path.basename(filePath, path.extname(filePath));
-
-  switch (convention) {
-    case 'PascalCase':
-      // 첫 글자 대문자, 언더스코어/하이픈 없음
-      if (!/^[A-Z][a-zA-Z0-9]*$/.test(fileName)) {
-        return {
-          valid: false,
-          message: `PascalCase 위반: ${fileName}`,
-          suggestion: fileName.charAt(0).toUpperCase() + fileName.slice(1).replace(/[-_](.)/g, (_, c) => c.toUpperCase()),
-        };
-      }
-      break;
-
-    case 'camelCase':
-      // 첫 글자 소문자, 언더스코어/하이픈 없음
-      if (!/^[a-z][a-zA-Z0-9]*$/.test(fileName)) {
-        return {
-          valid: false,
-          message: `camelCase 위반: ${fileName}`,
-          suggestion: fileName.charAt(0).toLowerCase() + fileName.slice(1).replace(/[-_](.)/g, (_, c) => c.toUpperCase()),
-        };
-      }
-      break;
-
-    case 'snake_case':
-      // 소문자와 언더스코어만
-      if (!/^[a-z][a-z0-9_]*$/.test(fileName)) {
-        return {
-          valid: false,
-          message: `snake_case 위반: ${fileName}`,
-          suggestion: fileName.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, ''),
-        };
-      }
-      break;
-
-    case 'kebab-case':
-      // 소문자와 하이픈만
-      if (!/^[a-z][a-z0-9-]*$/.test(fileName)) {
-        return {
-          valid: false,
-          message: `kebab-case 위반: ${fileName}`,
-          suggestion: fileName.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, ''),
-        };
-      }
-      break;
-  }
-
-  return { valid: true };
-}
-
-/**
- * Entity 파일에서 필수 컬럼 검증
- */
-function validateRequiredColumns(entityContent, filePath, requiredColumns) {
-  const violations = [];
-
-  for (const column of requiredColumns) {
-    // @Column 데코레이터와 함께 컬럼명 찾기
-    const columnRegex = new RegExp(`@Column[^)]*\\)[\\s\\S]*?${column}\\s*[:\\?]`, 'i');
-    const propertyRegex = new RegExp(`${column}\\s*[:\\?]`, 'i');
-
-    if (!columnRegex.test(entityContent) && !propertyRegex.test(entityContent)) {
-      violations.push({
-        file: filePath,
-        message: `필수 컬럼 누락: ${column}`,
-        suggestion: `@Column()\n  ${column}: Date;`,
-      });
-    }
-  }
-
-  return violations;
-}
-
-/**
- * 파일 목록 재귀 수집
- */
-function collectFiles(dirPath, extensions = ['.ts', '.tsx', '.js', '.jsx']) {
-  const files = [];
-
-  if (!fs.existsSync(dirPath)) {
-    return files;
-  }
-
-  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(dirPath, entry.name);
-
-    // 제외할 폴더
-    if (entry.isDirectory()) {
-      if (['node_modules', '.git', 'dist', 'build', '.next'].includes(entry.name)) {
-        continue;
-      }
-      files.push(...collectFiles(fullPath, extensions));
-    } else if (entry.isFile()) {
-      const ext = path.extname(entry.name);
-      if (extensions.includes(ext)) {
-        files.push(fullPath);
-      }
-    }
-  }
-
-  return files;
-}
-
-/**
- * docuking_validate 핸들러
- */
-export async function handleValidate(args) {
-  const { localPath, policy, targetPath, autoFix = false } = args;
-
-  if (!localPath) {
-    return {
-      content: [{
-        type: 'text',
-        text: '오류: localPath가 필요합니다.',
-      }],
-    };
-  }
-
-  // 정책 파일 경로 (우선순위: .claude/rules/local/ > yy_All_Docu/_Policy/)
-  const localRulesPath = path.join(localPath, '.claude', 'rules', 'local');
-  const policyFolderPath = path.join(localPath, 'yy_All_Docu', '_Policy');
-
-  // 정책 파일 수집
-  const policyFiles = [];
-
-  // .claude/rules/local/ 에서 정책 파일 찾기
-  if (fs.existsSync(localRulesPath)) {
-    const files = fs.readdirSync(localRulesPath).filter(f => f.endsWith('.md'));
-    files.forEach(f => {
-      policyFiles.push({
-        name: f,
-        path: path.join(localRulesPath, f),
-        source: 'local_rules',
-      });
-    });
-  }
-
-  // yy_All_Docu/_Policy/ 에서 정책 파일 찾기
-  if (fs.existsSync(policyFolderPath)) {
-    const files = fs.readdirSync(policyFolderPath).filter(f => f.endsWith('.md'));
-    files.forEach(f => {
-      // 이미 local_rules에 있으면 스킵
-      if (!policyFiles.find(p => p.name === f)) {
-        policyFiles.push({
-          name: f,
-          path: path.join(policyFolderPath, f),
-          source: '_Policy',
-        });
-      }
-    });
-  }
-
-  if (policyFiles.length === 0) {
-    return {
-      content: [{
-        type: 'text',
-        text: `정책 파일을 찾을 수 없습니다.
-
-검색 위치:
-- ${localRulesPath}
-- ${policyFolderPath}
-
-정책 파일을 yy_All_Docu/_Policy/ 폴더에 작성하거나,
-Pull을 실행하여 킹캐스트로 정책을 로컬화하세요.`,
-      }],
-    };
-  }
-
-  // 특정 정책만 검증
-  let targetPolicies = policyFiles;
-  if (policy) {
-    targetPolicies = policyFiles.filter(p => p.name.includes(policy));
-    if (targetPolicies.length === 0) {
-      return {
-        content: [{
-          type: 'text',
-          text: `정책 파일을 찾을 수 없습니다: ${policy}
-
-사용 가능한 정책:
-${policyFiles.map(p => `- ${p.name}`).join('\n')}`,
-        }],
-      };
-    }
-  }
-
-  // 규칙 추출
-  const allRules = [];
-  for (const policyFile of targetPolicies) {
-    try {
-      const content = fs.readFileSync(policyFile.path, 'utf-8');
-      const rules = extractRulesFromPolicy(content, policyFile.name);
-      allRules.push(...rules);
-    } catch (e) {
-      console.error(`[KingValidate] 정책 파일 읽기 실패: ${policyFile.path} - ${e.message}`);
-    }
-  }
-
-  if (allRules.length === 0) {
-    return {
-      content: [{
-        type: 'text',
-        text: `정책 파일에서 검증 가능한 규칙을 찾을 수 없습니다.
-
-검사한 정책:
-${targetPolicies.map(p => `- ${p.name}`).join('\n')}
-
-💡 정책 파일에 다음 형식으로 규칙을 작성하세요:
-- \`폴더명/\` - 필수 폴더
-- 파일명: PascalCase
-- 필수 컬럼: \`createdAt\`, \`updatedAt\`
-- 금지: \`any\` 타입 사용`,
-      }],
-    };
-  }
-
-  // 검증 대상 파일 수집
-  const searchPath = targetPath ? path.join(localPath, targetPath) : localPath;
-  const codeFiles = collectFiles(searchPath);
-
-  // 검증 실행
-  const violations = [];
-  const passed = [];
-
-  // 폴더 존재 검증
-  const folderRules = allRules.filter(r => r.type === 'folder_exists');
-  for (const rule of folderRules) {
-    const result = validateFolderExists(localPath, rule.pattern);
-    if (!result.valid) {
-      violations.push({
-        policy: rule.policy,
-        type: 'folder',
-        message: result.message,
-        suggestion: result.suggestion,
-      });
-    } else {
-      passed.push({
-        policy: rule.policy,
-        type: 'folder',
-        message: `폴더 존재: ${rule.pattern}`,
-      });
-    }
-  }
-
-  // 명명 규칙 검증
-  const namingRules = allRules.filter(r => r.type === 'naming_convention');
-  for (const file of codeFiles) {
-    for (const rule of namingRules) {
-      // 타겟에 맞는 파일인지 확인 (예: "컴포넌트 파일명" → .tsx 파일)
-      const ext = path.extname(file);
-      const isComponent = (ext === '.tsx' || ext === '.jsx') &&
-                          (file.includes('components') || file.includes('Components'));
-
-      if (rule.target?.includes('컴포넌트') && isComponent) {
-        const result = validateNamingConvention(file, rule.convention);
-        if (!result.valid) {
-          violations.push({
-            policy: rule.policy,
-            type: 'naming',
-            file: path.relative(localPath, file),
-            message: result.message,
-            suggestion: result.suggestion,
-          });
-        }
-      }
-    }
-  }
-
-  // 필수 컬럼 검증 (Entity 파일)
-  const columnRules = allRules.filter(r => r.type === 'required_column');
-  if (columnRules.length > 0) {
-    const requiredColumns = columnRules.map(r => r.column);
-    const entityFiles = codeFiles.filter(f =>
-      f.includes('entity') || f.includes('Entity') || f.includes('entities')
-    );
-
-    for (const entityFile of entityFiles) {
-      try {
-        const content = fs.readFileSync(entityFile, 'utf-8');
-        const columnViolations = validateRequiredColumns(content, entityFile, requiredColumns);
-        columnViolations.forEach(v => {
-          violations.push({
-            policy: columnRules[0].policy,
-            type: 'column',
-            file: path.relative(localPath, v.file),
-            message: v.message,
-            suggestion: v.suggestion,
-          });
-        });
-      } catch (e) {
-        console.error(`[KingValidate] Entity 파일 읽기 실패: ${entityFile}`);
-      }
-    }
-  }
-
-  // 결과 포맷팅
-  let resultText = `# 킹밸리데이트 결과
-
-검사 대상: ${targetPath || '전체'}
-정책 파일: ${targetPolicies.length}개
-추출된 규칙: ${allRules.length}개
-검사 파일: ${codeFiles.length}개
-
-`;
-
-  if (violations.length === 0) {
-    resultText += `## ✅ 모든 검증 통과!
-
-${passed.length}개 규칙을 검증했습니다.`;
-  } else {
-    resultText += `## ❌ 위반 발견: ${violations.length}건
-
-`;
-
-    // 정책별로 그룹화
-    const byPolicy = {};
-    violations.forEach(v => {
-      if (!byPolicy[v.policy]) {
-        byPolicy[v.policy] = [];
-      }
-      byPolicy[v.policy].push(v);
-    });
-
-    for (const [policyName, policyViolations] of Object.entries(byPolicy)) {
-      resultText += `### [위반] ${policyName}\n`;
-      policyViolations.forEach(v => {
-        if (v.file) {
-          resultText += `  - ${v.file} - ${v.message}\n`;
-        } else {
-          resultText += `  - ${v.message}\n`;
-        }
-        if (v.suggestion) {
-          resultText += `    💡 제안: ${v.suggestion}\n`;
-        }
-      });
-      resultText += '\n';
-    }
-  }
-
-  // 검증된 규칙 요약
-  resultText += `\n## 검증된 규칙
-
-`;
-  const ruleTypes = {};
-  allRules.forEach(r => {
-    ruleTypes[r.type] = (ruleTypes[r.type] || 0) + 1;
-  });
-  for (const [type, count] of Object.entries(ruleTypes)) {
-    resultText += `- ${type}: ${count}개\n`;
-  }
-
-  return {
-    content: [{
-      type: 'text',
-      text: resultText,
-    }],
-  };
-}
+/**
+ * DocuKing MCP - 킹밸리데이트 핸들러
+ * 코드가 정책을 준수하는지 검증
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * 정책 파일에서 검증 규칙 추출
+ * @param {string} policyContent - 정책 파일 내용
+ * @param {string} policyName - 정책 파일 이름
+ * @returns {Array} 추출된 규칙 목록
+ */
+function extractRulesFromPolicy(policyContent, policyName) {
+  const rules = [];
+
+  // 코드 블록 내의 규칙 패턴 추출
+  // 예: ```폴더명/``` 또는 ```파일패턴```
+  const codeBlockRegex = /```([^`]+)```/g;
+  let match;
+
+  // 폴더 구조 정책 (01_folder_structure.md)
+  if (policyName.includes('folder_structure')) {
+    // 폴더 패턴 추출: "src/components/" 같은 패턴
+    const folderPatterns = policyContent.match(/[-*]\s*`([^`]+\/)`/g);
+    if (folderPatterns) {
+      folderPatterns.forEach(p => {
+        const folder = p.match(/`([^`]+\/)`/)?.[1];
+        if (folder) {
+          rules.push({
+            type: 'folder_exists',
+            pattern: folder,
+            policy: policyName,
+          });
+        }
+      });
+    }
+
+    // 금지 패턴 추출: "금지", "하지 말 것", "사용하지 않음" 등
+    const forbiddenLines = policyContent.split('\n').filter(line =>
+      line.includes('금지') || line.includes('하지 말') || line.includes('사용하지 않')
+    );
+    forbiddenLines.forEach(line => {
+      const pattern = line.match(/`([^`]+)`/)?.[1];
+      if (pattern) {
+        rules.push({
+          type: 'forbidden_pattern',
+          pattern: pattern,
+          message: line.trim(),
+          policy: policyName,
+        });
+      }
+    });
+  }
+
+  // 명명 규칙 정책 (02_naming_convention.md)
+  if (policyName.includes('naming_convention')) {
+    // PascalCase 규칙
+    if (policyContent.includes('PascalCase')) {
+      const pascalPatterns = policyContent.match(/[-*]\s*([^:]+):\s*PascalCase/gi);
+      if (pascalPatterns) {
+        pascalPatterns.forEach(p => {
+          const target = p.match(/[-*]\s*([^:]+):/)?.[1]?.trim();
+          if (target) {
+            rules.push({
+              type: 'naming_convention',
+              convention: 'PascalCase',
+              target: target,
+              policy: policyName,
+            });
+          }
+        });
+      }
+    }
+
+    // camelCase 규칙
+    if (policyContent.includes('camelCase')) {
+      const camelPatterns = policyContent.match(/[-*]\s*([^:]+):\s*camelCase/gi);
+      if (camelPatterns) {
+        camelPatterns.forEach(p => {
+          const target = p.match(/[-*]\s*([^:]+):/)?.[1]?.trim();
+          if (target) {
+            rules.push({
+              type: 'naming_convention',
+              convention: 'camelCase',
+              target: target,
+              policy: policyName,
+            });
+          }
+        });
+      }
+    }
+
+    // snake_case 규칙
+    if (policyContent.includes('snake_case')) {
+      const snakePatterns = policyContent.match(/[-*]\s*([^:]+):\s*snake_case/gi);
+      if (snakePatterns) {
+        snakePatterns.forEach(p => {
+          const target = p.match(/[-*]\s*([^:]+):/)?.[1]?.trim();
+          if (target) {
+            rules.push({
+              type: 'naming_convention',
+              convention: 'snake_case',
+              target: target,
+              policy: policyName,
+            });
+          }
+        });
+      }
+    }
+  }
+
+  // DB 스키마 정책 (05_database_schema.md)
+  if (policyName.includes('database_schema')) {
+    // 필수 컬럼 추출
+    const requiredColumns = policyContent.match(/필수[^:]*:\s*([^\n]+)/gi);
+    if (requiredColumns) {
+      requiredColumns.forEach(line => {
+        const columns = line.match(/`([^`]+)`/g);
+        if (columns) {
+          columns.forEach(col => {
+            rules.push({
+              type: 'required_column',
+              column: col.replace(/`/g, ''),
+              policy: policyName,
+            });
+          });
+        }
+      });
+    }
+
+    // 컬럼 명명 규칙
+    if (policyContent.includes('snake_case') && policyContent.includes('컬럼')) {
+      rules.push({
+        type: 'column_naming',
+        convention: 'snake_case',
+        policy: policyName,
+      });
+    }
+  }
+
+  // API 규칙 정책 (03_api_convention.md)
+  if (policyName.includes('api_convention')) {
+    // REST 규칙 추출
+    const restRules = policyContent.match(/[-*]\s*(GET|POST|PUT|DELETE|PATCH)\s+([^\n]+)/gi);
+    if (restRules) {
+      restRules.forEach(rule => {
+        const method = rule.match(/(GET|POST|PUT|DELETE|PATCH)/i)?.[1];
+        const description = rule.replace(/[-*]\s*(GET|POST|PUT|DELETE|PATCH)/i, '').trim();
+        if (method) {
+          rules.push({
+            type: 'api_method',
+            method: method.toUpperCase(),
+            description: description,
+            policy: policyName,
+          });
+        }
+      });
+    }
+  }
+
+  return rules;
+}
+
+/**
+ * 폴더 존재 여부 검증
+ */
+function validateFolderExists(basePath, folderPattern) {
+  const fullPath = path.join(basePath, folderPattern.replace(/\/$/, ''));
+  if (!fs.existsSync(fullPath)) {
+    return {
+      valid: false,
+      message: `폴더가 존재하지 않음: ${folderPattern}`,
+      suggestion: `mkdir -p ${fullPath}`,
+    };
+  }
+  return { valid: true };
+}
+
+/**
+ * 파일명 명명 규칙 검증
+ */
+function validateNamingConvention(filePath, convention) {
+  const fileName = path.basename(filePath, path.extname(filePath));
+
+  switch (convention) {
+    case 'PascalCase':
+      // 첫 글자 대문자, 언더스코어/하이픈 없음
+      if (!/^[A-Z][a-zA-Z0-9]*$/.test(fileName)) {
+        return {
+          valid: false,
+          message: `PascalCase 위반: ${fileName}`,
+          suggestion: fileName.charAt(0).toUpperCase() + fileName.slice(1).replace(/[-_](.)/g, (_, c) => c.toUpperCase()),
+        };
+      }
+      break;
+
+    case 'camelCase':
+      // 첫 글자 소문자, 언더스코어/하이픈 없음
+      if (!/^[a-z][a-zA-Z0-9]*$/.test(fileName)) {
+        return {
+          valid: false,
+          message: `camelCase 위반: ${fileName}`,
+          suggestion: fileName.charAt(0).toLowerCase() + fileName.slice(1).replace(/[-_](.)/g, (_, c) => c.toUpperCase()),
+        };
+      }
+      break;
+
+    case 'snake_case':
+      // 소문자와 언더스코어만
+      if (!/^[a-z][a-z0-9_]*$/.test(fileName)) {
+        return {
+          valid: false,
+          message: `snake_case 위반: ${fileName}`,
+          suggestion: fileName.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, ''),
+        };
+      }
+      break;
+
+    case 'kebab-case':
+      // 소문자와 하이픈만
+      if (!/^[a-z][a-z0-9-]*$/.test(fileName)) {
+        return {
+          valid: false,
+          message: `kebab-case 위반: ${fileName}`,
+          suggestion: fileName.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, ''),
+        };
+      }
+      break;
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Entity 파일에서 필수 컬럼 검증
+ */
+function validateRequiredColumns(entityContent, filePath, requiredColumns) {
+  const violations = [];
+
+  for (const column of requiredColumns) {
+    // @Column 데코레이터와 함께 컬럼명 찾기
+    const columnRegex = new RegExp(`@Column[^)]*\\)[\\s\\S]*?${column}\\s*[:\\?]`, 'i');
+    const propertyRegex = new RegExp(`${column}\\s*[:\\?]`, 'i');
+
+    if (!columnRegex.test(entityContent) && !propertyRegex.test(entityContent)) {
+      violations.push({
+        file: filePath,
+        message: `필수 컬럼 누락: ${column}`,
+        suggestion: `@Column()\n  ${column}: Date;`,
+      });
+    }
+  }
+
+  return violations;
+}
+
+/**
+ * 파일 목록 재귀 수집
+ */
+function collectFiles(dirPath, extensions = ['.ts', '.tsx', '.js', '.jsx']) {
+  const files = [];
+
+  if (!fs.existsSync(dirPath)) {
+    return files;
+  }
+
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+
+    // 제외할 폴더
+    if (entry.isDirectory()) {
+      if (['node_modules', '.git', 'dist', 'build', '.next'].includes(entry.name)) {
+        continue;
+      }
+      files.push(...collectFiles(fullPath, extensions));
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name);
+      if (extensions.includes(ext)) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  return files;
+}
+
+/**
+ * docuking_validate 핸들러
+ */
+export async function handleValidate(args) {
+  const { localPath, policy, targetPath, autoFix = false } = args;
+
+  if (!localPath) {
+    return {
+      content: [{
+        type: 'text',
+        text: '오류: localPath가 필요합니다.',
+      }],
+    };
+  }
+
+  // 정책 파일 경로 (우선순위: .claude/rules/local/ > xx_Policy/)
+  const localRulesPath = path.join(localPath, '.claude', 'rules', 'local');
+  const policyFolderPath = path.join(localPath, 'xx_Policy');
+
+  // 정책 파일 수집
+  const policyFiles = [];
+
+  // .claude/rules/local/ 에서 정책 파일 찾기
+  if (fs.existsSync(localRulesPath)) {
+    const files = fs.readdirSync(localRulesPath).filter(f => f.endsWith('.md'));
+    files.forEach(f => {
+      policyFiles.push({
+        name: f,
+        path: path.join(localRulesPath, f),
+        source: 'local_rules',
+      });
+    });
+  }
+
+  // xx_Policy/ 에서 정책 파일 찾기
+  if (fs.existsSync(policyFolderPath)) {
+    const files = fs.readdirSync(policyFolderPath).filter(f => f.endsWith('.md'));
+    files.forEach(f => {
+      // 이미 local_rules에 있으면 스킵
+      if (!policyFiles.find(p => p.name === f)) {
+        policyFiles.push({
+          name: f,
+          path: path.join(policyFolderPath, f),
+          source: '_Policy',
+        });
+      }
+    });
+  }
+
+  if (policyFiles.length === 0) {
+    return {
+      content: [{
+        type: 'text',
+        text: `정책 파일을 찾을 수 없습니다.
+
+검색 위치:
+- ${localRulesPath}
+- ${policyFolderPath}
+
+정책 파일을 xx_Policy/ 폴더에 작성하거나,
+Pull을 실행하여 킹캐스트로 정책을 로컬화하세요.`,
+      }],
+    };
+  }
+
+  // 특정 정책만 검증
+  let targetPolicies = policyFiles;
+  if (policy) {
+    targetPolicies = policyFiles.filter(p => p.name.includes(policy));
+    if (targetPolicies.length === 0) {
+      return {
+        content: [{
+          type: 'text',
+          text: `정책 파일을 찾을 수 없습니다: ${policy}
+
+사용 가능한 정책:
+${policyFiles.map(p => `- ${p.name}`).join('\n')}`,
+        }],
+      };
+    }
+  }
+
+  // 규칙 추출
+  const allRules = [];
+  for (const policyFile of targetPolicies) {
+    try {
+      const content = fs.readFileSync(policyFile.path, 'utf-8');
+      const rules = extractRulesFromPolicy(content, policyFile.name);
+      allRules.push(...rules);
+    } catch (e) {
+      console.error(`[KingValidate] 정책 파일 읽기 실패: ${policyFile.path} - ${e.message}`);
+    }
+  }
+
+  if (allRules.length === 0) {
+    return {
+      content: [{
+        type: 'text',
+        text: `정책 파일에서 검증 가능한 규칙을 찾을 수 없습니다.
+
+검사한 정책:
+${targetPolicies.map(p => `- ${p.name}`).join('\n')}
+
+💡 정책 파일에 다음 형식으로 규칙을 작성하세요:
+- \`폴더명/\` - 필수 폴더
+- 파일명: PascalCase
+- 필수 컬럼: \`createdAt\`, \`updatedAt\`
+- 금지: \`any\` 타입 사용`,
+      }],
+    };
+  }
+
+  // 검증 대상 파일 수집
+  const searchPath = targetPath ? path.join(localPath, targetPath) : localPath;
+  const codeFiles = collectFiles(searchPath);
+
+  // 검증 실행
+  const violations = [];
+  const passed = [];
+
+  // 폴더 존재 검증
+  const folderRules = allRules.filter(r => r.type === 'folder_exists');
+  for (const rule of folderRules) {
+    const result = validateFolderExists(localPath, rule.pattern);
+    if (!result.valid) {
+      violations.push({
+        policy: rule.policy,
+        type: 'folder',
+        message: result.message,
+        suggestion: result.suggestion,
+      });
+    } else {
+      passed.push({
+        policy: rule.policy,
+        type: 'folder',
+        message: `폴더 존재: ${rule.pattern}`,
+      });
+    }
+  }
+
+  // 명명 규칙 검증
+  const namingRules = allRules.filter(r => r.type === 'naming_convention');
+  for (const file of codeFiles) {
+    for (const rule of namingRules) {
+      // 타겟에 맞는 파일인지 확인 (예: "컴포넌트 파일명" → .tsx 파일)
+      const ext = path.extname(file);
+      const isComponent = (ext === '.tsx' || ext === '.jsx') &&
+                          (file.includes('components') || file.includes('Components'));
+
+      if (rule.target?.includes('컴포넌트') && isComponent) {
+        const result = validateNamingConvention(file, rule.convention);
+        if (!result.valid) {
+          violations.push({
+            policy: rule.policy,
+            type: 'naming',
+            file: path.relative(localPath, file),
+            message: result.message,
+            suggestion: result.suggestion,
+          });
+        }
+      }
+    }
+  }
+
+  // 필수 컬럼 검증 (Entity 파일)
+  const columnRules = allRules.filter(r => r.type === 'required_column');
+  if (columnRules.length > 0) {
+    const requiredColumns = columnRules.map(r => r.column);
+    const entityFiles = codeFiles.filter(f =>
+      f.includes('entity') || f.includes('Entity') || f.includes('entities')
+    );
+
+    for (const entityFile of entityFiles) {
+      try {
+        const content = fs.readFileSync(entityFile, 'utf-8');
+        const columnViolations = validateRequiredColumns(content, entityFile, requiredColumns);
+        columnViolations.forEach(v => {
+          violations.push({
+            policy: columnRules[0].policy,
+            type: 'column',
+            file: path.relative(localPath, v.file),
+            message: v.message,
+            suggestion: v.suggestion,
+          });
+        });
+      } catch (e) {
+        console.error(`[KingValidate] Entity 파일 읽기 실패: ${entityFile}`);
+      }
+    }
+  }
+
+  // 결과 포맷팅
+  let resultText = `# 킹밸리데이트 결과
+
+검사 대상: ${targetPath || '전체'}
+정책 파일: ${targetPolicies.length}개
+추출된 규칙: ${allRules.length}개
+검사 파일: ${codeFiles.length}개
+
+`;
+
+  if (violations.length === 0) {
+    resultText += `## ✅ 모든 검증 통과!
+
+${passed.length}개 규칙을 검증했습니다.`;
+  } else {
+    resultText += `## ❌ 위반 발견: ${violations.length}건
+
+`;
+
+    // 정책별로 그룹화
+    const byPolicy = {};
+    violations.forEach(v => {
+      if (!byPolicy[v.policy]) {
+        byPolicy[v.policy] = [];
+      }
+      byPolicy[v.policy].push(v);
+    });
+
+    for (const [policyName, policyViolations] of Object.entries(byPolicy)) {
+      resultText += `### [위반] ${policyName}\n`;
+      policyViolations.forEach(v => {
+        if (v.file) {
+          resultText += `  - ${v.file} - ${v.message}\n`;
+        } else {
+          resultText += `  - ${v.message}\n`;
+        }
+        if (v.suggestion) {
+          resultText += `    💡 제안: ${v.suggestion}\n`;
+        }
+      });
+      resultText += '\n';
+    }
+  }
+
+  // 검증된 규칙 요약
+  resultText += `\n## 검증된 규칙
+
+`;
+  const ruleTypes = {};
+  allRules.forEach(r => {
+    ruleTypes[r.type] = (ruleTypes[r.type] || 0) + 1;
+  });
+  for (const [type, count] of Object.entries(ruleTypes)) {
+    resultText += `- ${type}: ${count}개\n`;
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: resultText,
+    }],
+  };
+}