Create design_implementation_validator.py

validators/design_implementation_validator.py

@@ -0,0 +1,575 @@
+import re
+import ast
+import difflib
+from typing import Dict, Any, List, Optional, Set, Tuple
+
+from validators.base import BaseValidator, Validator
+
+class DesignImplementationValidator(BaseValidator, Validator):
+    """設計書と実装コードの整合性を検証するクラス"""
+    
+    def __init__(self, client=None):
+        """設計・実装検証クラスの初期化"""
+        super().__init__(client)
+        self.validation_results = {}
+    
+    async def validate(self, content, context=None):
+        """設計書と実装コードの整合性を検証する（インターフェース実装）"""
+        # contentが設計書、contextが実装コードの場合
+        if context and isinstance(content, str) and isinstance(context, str):
+            design_doc = content
+            implementation_code = context
+        else:
+            # 単一コンテンツの場合、設計書と実装コードを分離
+            design_code_parts = self._separate_design_and_code(content)
+            if design_code_parts:
+                design_doc, implementation_code = design_code_parts
+            else:
+                # 分離できない場合は、元のコンテンツをそのまま返す
+                return content
+        
+        # 検証実行
+        validation_result = self.validate_design_implementation(design_doc, implementation_code)
+        self.validation_results = validation_result
+        
+        # 検証結果に基づいて注釈を追加
+        if not validation_result.get("is_compliant", True):
+            implementation_code = self._add_compliance_notes(implementation_code, validation_result)
+        
+        return implementation_code
+    
+    def get_result_summary(self):
+        """検証結果の要約を返す（インターフェース実装）"""
+        if not self.validation_results:
+            return "設計書と実装コードの整合性はまだ検証されていません。"
+        
+        is_compliant = self.validation_results.get("is_compliant", True)
+        compliance_score = self.validation_results.get("compliance_score", 0.0)
+        
+        if is_compliant:
+            return f"設計書と実装コードは整合しています（整合性スコア: {compliance_score}/10.0）"
+        
+        missing_components = self.validation_results.get("missing_components", [])
+        missing_methods = self.validation_results.get("missing_methods", [])
+        missing_requirements = self.validation_results.get("missing_requirements", [])
+        
+        summary = f"設計書と実装コードに不整合があります（整合性スコア: {compliance_score}/10.0）\n\n"
+        
+        if missing_components:
+            summary += "不足しているコンポーネント:\n"
+            summary += "\n".join([f"- {component}" for component in missing_components[:3]])
+            if len(missing_components) > 3:
+                summary += f"\n...他{len(missing_components) - 3}個"
+            summary += "\n\n"
+        
+        if missing_methods:
+            summary += "不足しているメソッド:\n"
+            summary += "\n".join([f"- {method}" for method in missing_methods[:3]])
+            if len(missing_methods) > 3:
+                summary += f"\n...他{len(missing_methods) - 3}個"
+            summary += "\n\n"
+        
+        if missing_requirements:
+            summary += "未実装の要件:\n"
+            summary += "\n".join([f"- {req}" for req in missing_requirements[:3]])
+            if len(missing_requirements) > 3:
+                summary += f"\n...他{len(missing_requirements) - 3}個"
+        
+        return summary
+    
+    def _separate_design_and_code(self, content: str) -> Optional[Tuple[str, str]]:
+        """コンテンツから設計書部分と実装コード部分を分離する"""
+        # 設計書セクションのマーカー
+        design_markers = [
+            "# 設計書", "## 設計書", "# 設計", "## 設計",
+            "# アーキテクチャ設計", "# 詳細設計",
+            "# Design Document", "## Design Document",
+            "# Architecture", "## Architecture"
+        ]
+        
+        # 実装コードセクションのマーカー
+        code_markers = [
+            "# 実装", "## 実装", "# 実装コード", "## 実装コード",
+            "# Implementation", "## Implementation",
+            "# Code", "## Code",
+            "```python", "```java", "```javascript", "```cpp"
+        ]
+        
+        # 設計書と実装コードの開始位置を検出
+        design_start = -1
+        code_start = -1
+        
+        for marker in design_markers:
+            if marker in content:
+                design_start = content.find(marker)
+                break
+        
+        for marker in code_markers:
+            if marker in content:
+                marker_pos = content.find(marker)
+                if marker_pos > design_start:  # 設計書の後に出現するコードマーカー���み考慮
+                    code_start = marker_pos
+                    break
+        
+        # 設計書と実装コードの両方が見つかった場合
+        if design_start >= 0 and code_start > design_start:
+            design_doc = content[design_start:code_start].strip()
+            implementation_code = content[code_start:].strip()
+            return design_doc, implementation_code
+        
+        # 分離できない場合
+        return None
+    
+    def _add_compliance_notes(self, implementation_code: str, validation_result: Dict[str, Any]) -> str:
+        """検証結果に基づいて実装コードに注釈を追加する"""
+        notes = ["# 設計書との整合性の問題点:"]
+        
+        # 各種不足要素を注釈として追加
+        missing_components = validation_result.get("missing_components", [])
+        if missing_components:
+            notes.append("# 不足しているコンポーネント:")
+            for component in missing_components:
+                notes.append(f"# - {component}")
+        
+        missing_methods = validation_result.get("missing_methods", [])
+        if missing_methods:
+            notes.append("# 不足しているメソッド:")
+            for method in missing_methods:
+                notes.append(f"# - {method}")
+        
+        missing_requirements = validation_result.get("missing_requirements", [])
+        if missing_requirements:
+            notes.append("# 未実装の要件:")
+            for req in missing_requirements:
+                notes.append(f"# - {req}")
+        
+        # 提案があれば追加
+        suggestion = validation_result.get("suggestion")
+        if suggestion:
+            notes.append("# 提案:")
+            for line in suggestion.split("\n"):
+                notes.append(f"# {line}")
+        
+        # 注釈を実装コードの先頭に追加
+        notes_str = "\n".join(notes)
+        return f"{notes_str}\n\n{implementation_code}"
+    
+    def validate_design_implementation(self, design_doc: str, implementation_code: str) -> Dict[str, Any]:
+        """設計書と実装コードの整合性を検証する"""
+        result = {
+            "is_compliant": True,
+            "issues": [],
+            "missing_components": [],
+            "missing_methods": [],
+            "missing_requirements": [],
+            "extra_components": [],
+            "compliance_score": 0.0,
+            "suggestion": None
+        }
+        
+        # 設計書から要素を抽出
+        design_components = self._extract_design_components(design_doc)
+        
+        # 実装コードから要素を抽出
+        implementation_components = self._extract_implementation_components(implementation_code)
+        
+        # 設計書と実装の整合性を検証
+        self._validate_consistency(design_components, implementation_components, result)
+        
+        # 検証結果に基づいてコンプライアンススコアを計算
+        self._calculate_compliance_score(result)
+        
+        # 改善のための提案を生成
+        self._generate_suggestions(result)
+        
+        return result
+    
+    def _extract_design_components(self, design_doc: str) -> Dict[str, Any]:
+        """設計書からコンポーネント、クラス、メソッド、要件などを抽出する"""
+        components = {
+            "classes": [],
+            "interfaces": [],
+            "methods": {},
+            "attributes": {},
+            "requirements": [],
+            "dependencies": [],
+            "data_structures": []
+        }
+        
+        # 1. クラス定義の抽出
+        class_pattern = r'(class\s+(\w+)(?:\s*\(\s*\w+\s*\))?\s*:)'
+        for match in re.finditer(class_pattern, design_doc):
+            class_name = match.group(2)
+            components["classes"].append(class_name)
+            components["methods"][class_name] = []
+            components["attributes"][class_name] = []
+            
+            # クラス定義の範囲を特定
+            class_start = match.end()
+            next_class_match = re.search(class_pattern, design_doc[class_start:])
+            class_end = class_start + next_class_match.start() if next_class_match else len(design_doc)
+            class_body = design_doc[class_start:class_end]
+            
+            # メソッド定義の抽出
+            method_pattern = r'def\s+(\w+)\s*\((.*?)\)'
+            for method_match in re.finditer(method_pattern, class_body):
+                method_name = method_match.group(1)
+                components["methods"][class_name].append(method_name)
+            
+            # 属性の抽出（単純なパターンマッチング）
+            attribute_pattern = r'self\.(\w+)\s*='
+            for attr_match in re.finditer(attribute_pattern, class_body):
+                attr_name = attr_match.group(1)
+                if attr_name not in components["attributes"][class_name]:
+                    components["attributes"][class_name].append(attr_name)
+        
+        # 2. インターフェース定義の抽出（ABC, Protocolなど）
+        interface_pattern = r'(class\s+(\w+)(?:\s*\(\s*(?:ABC|Protocol)\s*\))?\s*:)'
+        for match in re.finditer(interface_pattern, design_doc):
+            interface_name = match.group(2)
+            if interface_name not in components["classes"]:  # クラスとして既に登録されていない場合
+                components["interfaces"].append(interface_name)
+                components["methods"][interface_name] = []
+                
+                # インターフェース定義の範囲を特定
+                interface_start = match.end()
+                next_interface_match = re.search(interface_pattern, design_doc[interface_start:])
+                interface_end = interface_start + next_interface_match.start() if next_interface_match else len(design_doc)
+                interface_body = design_doc[interface_start:interface_end]
+                
+                # メソッド定義の抽出
+                method_pattern = r'def\s+(\w+)\s*\((.*?)\)'
+                for method_match in re.finditer(method_pattern, interface_body):
+                    method_name = method_match.group(1)
+                    components["methods"][interface_name].append(method_name)
+        
+        # 3. 要件の抽出
+        requirement_sections = [
+            "要件", "機能要件", "非機能要件", "制約", "前提条件", 
+            "Requirements", "Functional Requirements", "Non-functional Requirements"
+        ]
+        
+        for section in requirement_sections:
+            section_match = re.search(rf'{section}[：:]\s*(.*?)(?=\n\n|\n#|\Z)', design_doc, re.DOTALL)
+            if section_match:
+                section_text = section_match.group(1).strip()
+                
+                # 箇条書きの抽出
+                bullet_patterns = [
+                    r'[-*•]\s*(.*?)(?=\n[-*•]|\n\n|\Z)',  # ハイフン、アスタリスク、中黒
+                    r'\d+\.\s*(.*?)(?=\n\d+\.|\n\n|\Z)'   # 番号付きリスト
+                ]
+                
+                for pattern in bullet_patterns:
+                    for req_match in re.finditer(pattern, section_text, re.DOTALL):
+                        requirement = req_match.group(1).strip()
+                        if requirement and requirement not in components["requirements"]:
+                            components["requirements"].append(requirement)
+        
+        # 4. データ構造の抽出
+        data_structure_patterns = [
+            r'(class|struct)\s+(\w+)',  # クラスまたは構造体
+            r'(enum)\s+(\w+)',  # 列挙型
+            r'(type|typedef)\s+(\w+)'  # 型定義
+        ]
+        
+        for pattern in data_structure_patterns:
+            for match in re.finditer(pattern, design_doc):
+                structure_type = match.group(1)
+                structure_name = match.group(2)
+                if structure_name not in components["classes"] and structure_name not in components["interfaces"]:
+                    components["data_structures"].append(structure_name)
+        
+        # 5. 依存関係の抽出
+        dependency_patterns = [
+            r'依存[：:]\s*(.*?)(?=\n\n|\Z)',
+            r'Dependencies[：:]\s*(.*?)(?=\n\n|\Z)',
+            r'利用[：:]\s*(.*?)(?=\n\n|\Z)',
+            r'Uses[：:]\s*(.*?)(?=\n\n|\Z)',
+            r'import\s+(\w+)',
+            r'from\s+(\w+)\s+import'
+        ]
+        
+        for pattern in dependency_patterns:
+            for match in re.finditer(pattern, design_doc):
+                dependency = match.group(1).strip()
+                if dependency and dependency not in components["dependencies"]:
+                    components["dependencies"].append(dependency)
+        
+        return components
+    
+    def _extract_implementation_components(self, implementation_code: str) -> Dict[str, Any]:
+        """実装コードからコンポーネント、クラス、メソッド、属性などを抽出する"""
+        components = {
+            "classes": [],
+            "interfaces": [],
+            "methods": {},
+            "attributes": {},
+            "imports": [],
+            "functions": []
+        }
+        
+        try:
+            # ASTを使ってPythonコードを解析
+            tree = ast.parse(implementation_code)
+            
+            # インポート文の抽出
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for name in node.names:
+                        components["imports"].append(name.name)
+                elif isinstance(node, ast.ImportFrom):
+                    if node.module:
+                        components["imports"].append(node.module)
+            
+            # クラスの抽出
+            for node in ast.walk(tree):
+                if isinstance(node, ast.ClassDef):
+                    class_name = node.name
+                    
+                    # イ���ターフェース（抽象クラス）かどうかを判定
+                    is_interface = False
+                    for base in node.bases:
+                        if isinstance(base, ast.Name) and base.id in ["ABC", "Protocol"]:
+                            is_interface = True
+                            break
+                    
+                    if is_interface:
+                        components["interfaces"].append(class_name)
+                    else:
+                        components["classes"].append(class_name)
+                    
+                    components["methods"][class_name] = []
+                    components["attributes"][class_name] = []
+                    
+                    # メソッドと属性の抽出
+                    for item in node.body:
+                        if isinstance(item, ast.FunctionDef):
+                            components["methods"][class_name].append(item.name)
+                        elif isinstance(item, ast.Assign):
+                            for target in item.targets:
+                                if isinstance(target, ast.Name):
+                                    components["attributes"][class_name].append(target.id)
+            
+            # トップレベル関数の抽出
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef) and node.name not in [m for methods in components["methods"].values() for m in methods]:
+                    if not any(isinstance(parent, ast.ClassDef) for parent in ast.iter_child_nodes(tree)):
+                        components["functions"].append(node.name)
+        
+        except SyntaxError as e:
+            print(f"[Warning] Syntax error during code analysis: {e}")
+            # 構文エラーの場合は正規表現ベースのフォールバック解析を使用
+            self._fallback_extract_implementation_components(implementation_code, components)
+        
+        return components
+    
+    def _fallback_extract_implementation_components(self, code: str, components: Dict[str, Any]) -> None:
+        """構文エラーがある場合のフォールバック抽出メソッド（正規表現ベース）"""
+        # クラス定義の抽出
+        class_pattern = r'class\s+(\w+)(?:\s*\(.*?\))?\s*:'
+        for match in re.finditer(class_pattern, code):
+            class_name = match.group(1)
+            if class_name not in components["classes"]:
+                components["classes"].append(class_name)
+                components["methods"][class_name] = []
+                components["attributes"][class_name] = []
+            
+            # クラス本体の抽出
+            class_start = match.end()
+            # 簡易的なブロック終了の検出（インデントベース）
+            class_body = ""
+            in_class = True
+            indent_level = None
+            
+            for line in code[class_start:].split('\n'):
+                if not line.strip():
+                    class_body += line + '\n'
+                    continue
+                
+                current_indent = len(line) - len(line.lstrip())
+                
+                if indent_level is None:
+                    if current_indent > 0:  # クラス本体の最初の行
+                        indent_level = current_indent
+                        class_body += line + '\n'
+                    continue
+                
+                if current_indent >= indent_level:
+                    class_body += line + '\n'
+                else:
+                    break  # クラスブロックの終了
+            
+            # メソッド定義の抽出
+            method_pattern = r'def\s+(\w+)\s*\('
+            for method_match in re.finditer(method_pattern, class_body):
+                method_name = method_match.group(1)
+                if method_name not in components["methods"][class_name]:
+                    components["methods"][class_name].append(method_name)
+            
+            # 属性の抽出
+            attribute_pattern = r'self\.(\w+)\s*='
+            for attr_match in re.finditer(attribute_pattern, class_body):
+                attr_name = attr_match.group(1)
+                if attr_name not in components["attributes"][class_name]:
+                    components["attributes"][class_name].append(attr_name)
+        
+        # インポート文の抽出
+        import_pattern = r'import\s+(\w+)'
+        for match in re.finditer(import_pattern, code):
+            import_name = match.group(1)
+            if import_name not in components["imports"]:
+                components["imports"].append(import_name)
+        
+        from_import_pattern = r'from\s+(\w+)\s+import'
+        for match in re.finditer(from_import_pattern, code):
+            import_name = match.group(1)
+            if import_name not in components["imports"]:
+                components["imports"].append(import_name)
+        
+        # トップレベル関数の抽出
+        function_pattern = r'^def\s+(\w+)\s*\('
+        for match in re.finditer(function_pattern, code, re.MULTILINE):
+            func_name = match.group(1)
+            if func_name not in components["functions"]:
+                components["functions"].append(func_name)
+    
+    def _validate_consistency(self, design: Dict[str, Any], implementation: Dict[str, Any], result: Dict[str, Any]) -> None:
+        """設計と実装の整合性を検証する"""
+        # 1. クラスの整合性チェック
+        for class_name in design["classes"]:
+            if class_name not in implementation["classes"] and class_name not in implementation["interfaces"]:
+                result["is_compliant"] = False
+                result["missing_components"].append(f"Class: {class_name}")
+                result["issues"].append(f"設計書で定義されているクラス '{class_name}' が実装に存在しません。")
+        
+        # 2. インターフェースの整合性チェック
+        for interface_name in design["interfaces"]:
+            if interface_name not in implementation["interfaces"] and interface_name not in implementation["classes"]:
+                result["is_compliant"] = False
+                result["missing_components"].append(f"Interface: {interface_name}")
+                result["issues"].append(f"設計書で定義されているインターフェース '{interface_name}' が実装に存在しません。")
+        
+        # 3. メソッドの整合性チェック
+        for class_name, methods in design["methods"].items():
+            if class_name in implementation["methods"]:
+                for method_name in methods:
+                    if method_name not in implementation["methods"][class_name]:
+                        result["is_compliant"] = False
+                        result["missing_methods"].append(f"{class_name}.{method_name}")
+                        result["issues"].append(f"設計書で定義されているメソッド '{class_name}.{method_name}' が実装に存在しません。")
+        
+        # 4. 属性の整合性チェック（厳密でない - 属性は実装時に追加されることもある）
+        for class_name, attrs in design["attributes"].items():
+            if class_name in implementation["attributes"]:
+                for attr_name in attrs:
+                    if attr_name not in implementation["attributes"][class_name]:
+                        # 属性の不一致は警告レベル
+                        result["issues"].append(f"設計書で定義されている属性 '{class_name}.{attr_name}' が実装に存在しません（警告）。")
+        
+        # 5. 要件の実装検証（キーワードベースの簡易検証）
+        code_text = implementation_code if hasattr(self, 'implementation_code') else ""
+        for req in design["requirements"]:
+            # 要件からキーワードを抽出
+            keywords = self._extract_keywords(req)
+            
+            # キーワードが実装に含まれているかチェック
+            if keywords and not all(keyword.lower() in code_text.lower() for keyword in keywords if len(keyword) > 3):
+                result["is_compliant"] = False
+                result["missing_requirements"].append(req)
+                result["issues"].append(f"要件 '{req}' が実装に反映されていない可能性があります。")
+        
+        # 6. 実装に存在する余分なコンポーネントを確認
+        for class_name in implementation["classes"]:
+            if class_name not in design["classes"] and class_name not in design["interfaces"]:
+                result["extra_components"].append(f"Class: {class_name}")
+                # 余分なコンポーネントは警告レベル
+                result["issues"].append(f"実装に存在するクラス '{class_name}' が設計書に定義されていません（警告）。")
+    
+    def _extract_keywords(self, text: str) -> List[str]:
+        """テキストから重要なキーワードを抽出する"""
+        # ストップワードを定義
+        stop_words = {
+            "a", "an", "the", "this", "that", "these", "those", 
+            "is", "are", "was", "were", "be", "been", "being",
+            "have", "has", "had", "do", "does", "did", "will", "would", "shall", "should",
+            "can", "could", "may", "might", "must", "and", "or", "but", "if", "then", "else",
+            "when", "where", "why", "how", "all", "any", "both", "each", "few", "more", "most",
+            "other", "some", "such", "no", "nor", "not", "only", "own", "same", "so", "than",
+            "too", "very", "を", "に", "は", "が", "で", "と", "から", "まで", "より", "して", "する", "ます", "です"
+        }
+        
+        # 単語分割（英語と日本語の両方に対応）
+        words = []
+        # 英単語の抽出
+        english_words = re.findall(r'\b[a-zA-Z]+\b', text.lower())
+        words.extend(english_words)
+        
+        # 日本語単語の簡易抽出（文字単位の分割）
+        japanese_text = re.sub(r'[a-zA-Z0-9\s]', '', text)
+        for char in japanese_text:
+            if char not in "、。！？「」『』（）［］【】…：；":
+                words.append(char)
+        
+        # ストップワードと短すぎる単語を除外
+        keywords = [w for w in words if w not in stop_words and len(w) > 1]
+        
+        # 重複を削除
+        unique_keywords = list(set(keywords))
+        
+        return unique_keywords
+    
+    def _calculate_compliance_score(self, result: Dict[str, Any]) -> None:
+        """コンプライアンススコアを計算する（0.0〜10.0の範囲）"""
+        # 初期スコア
+        score = 10.0
+        
+        # 不足しているコンポーネントごとに減点
+        score -= len(result["missing_components"]) * 2.0
+        
+        # 不足しているメソッドごとに減点
+        score -= len(result["missing_methods"]) * 1.0
+        
+        # 不足している要件ごとに減点
+        score -= len(result["missing_requirements"]) * 1.5
+        
+        # 余分なコンポーネントごとに軽く減点
+        score -= len(result["extra_components"]) * 0.5
+        
+        # スコアの範囲を調整
+        result["compliance_score"] = max(0.0, min(10.0, score))
+        
+        # コンプライアンス判定（スコアが7.0以上で合格）
+        result["is_compliant"] = result["compliance_score"] >= 7.0
+    
+    def _generate_suggestions(self, result: Dict[str, Any]) -> None:
+        """検証結果に基づいて改善提案を生成する"""
+        if result["is_compliant"]:
+            if result["compliance_score"] == 10.0:
+                result["suggestion"] = "設計書と実装は完全に一致しています。素晴らしい実装です。"
+            else:
+                result["suggestion"] = "設計書と実装は概ね一致していますが、いくつかの軽微な問題があります。詳細は issues リストを確認してください。"
+        else:
+            # 不足コンポーネントの提案
+            if result["missing_components"]:
+                result["suggestion"] = f"設計書で定義されている以下のコンポーネントを実装してください: {', '.join(result['missing_components'][:3])}"
+                if len(result["missing_components"]) > 3:
+                    result["suggestion"] += f" ... 他 {len(result['missing_components']) - 3} 件"
+            
+            # 不足メソッドの提案
+            elif result["missing_methods"]:
+                result["suggestion"] = f"設計書で定義されている以下のメソッドを実装してください: {', '.join(result['missing_methods'][:3])}"
+                if len(result["missing_methods"]) > 3:
+                    result["suggestion"] += f" ... 他 {len(result['missing_methods']) - 3} 件"
+            
+            # 不足要件の提案
+            elif result["missing_requirements"]:
+                result["suggestion"] = "以下の要件が実装に反映されていない可能性があります。要件を満たす機能を実装してください。"
+                for i, req in enumerate(result["missing_requirements"][:3]):
+                    result["suggestion"] += f"\n{i+1}. {req}"
+                if len(result["missing_requirements"]) > 3:
+                    result["suggestion"] += f"\n... 他 {len(result['missing_requirements']) - 3} 件"
+            
+            # 一般的な提案
+            else:
+                result["suggestion"] = "設計書と実装の間にいくつかの不一致があります。issues リストを確認して修正してください。"