Create code_verifier.py

validators/code_verifier.py

@@ -0,0 +1,959 @@
+import json
+import asyncio
+import copy
+import re
+import ast
+import tempfile
+import subprocess
+import os
+from typing import Dict, Any, List, Optional, Union, Tuple, Set
+
+from validators.base import BaseValidator, Validator
+
+class CodeVerifier(BaseValidator, Validator):
+    """コード検証を行うクラス"""
+    
+    def __init__(self, client):
+        """検証クライアントを初期化"""
+        super().__init__(client)
+        # 検証用のモデル
+        self.verify_model = "qwen-2.5-coder-32b"  # コード検証に特化したモデル
+        self.verification_results = {}
+    
+    async def validate(self, content, context=None):
+        """コード検証を実行する（インターフェース実装）"""
+        result = await self.verify_code_blocks(content, context)
+        self.verification_results = result["verification_result"]
+        return result["verified_content"]
+    
+    def get_result_summary(self):
+        """検証結果の要約を返す（インターフェース実装）"""
+        if not self.verification_results:
+            return "検証はまだ実行されていません。"
+        return self.verification_results.get("verification_summary", "要約は利用できません。")
+    
+    def _extract_problem_description(self, user_input: str) -> Optional[str]:
+        """ユーザー入力から問題記述を抽出する"""
+        # 問題文を示す一般的なパターン
+        problem_indicators = [
+            "問題:", "問題文:", "**問題:**", "# 問題", "課題:", "要件:",
+            "Problem:", "Task:", "Question:", "Exercise:",
+            "以下の問題", "次の問題", "この問題"
+        ]
+        
+        # 制約条件を示す一般的なパターン
+        constraint_indicators = [
+            "制約:", "条件:", "ただし", "ここで", "なお",
+            "Constraints:", "Note:", "Where:", "Given:",
+            "評価ポイント", "注意点", "考慮点", "エッジケース"
+        ]
+        
+        # 例を示す一般的なパターン
+        example_indicators = [
+            "例:", "入力例:", "出力例:", "サンプル:", "テストケース:",
+            "Example:", "Input:", "Output:", "Sample:", "Test case:"
+        ]
+        
+        problem_desc = None
+        
+        # 問題文のパターンマッチング
+        for indicator in problem_indicators:
+            if indicator in user_input:
+                # 問題文の開始位置を見つける
+                start_pos = user_input.find(indicator) + len(indicator)
+                
+                # 次のセクション（例や制約）の開始位置を見つける
+                end_pos = len(user_input)
+                for end_indicator in example_indicators + constraint_indicators:
+                    pos = user_input.find(end_indicator, start_pos)
+                    if pos != -1 and pos < end_pos:
+                        end_pos = pos
+                
+                # 問題文を抽出
+                problem_desc = user_input[start_pos:end_pos].strip()
+                break
+        
+        # 問題文が見つからない場合、ユーザー入力全体を使用
+        if not problem_desc:
+            return user_input
+        
+        # 制約条件の抽出と追加
+        constraints = []
+        for indicator in constraint_indicators:
+            if indicator in user_input:
+                # 制約の開始位置を見つける
+                start_pos = user_input.find(indicator) + len(indicator)
+                
+                # 次のセクションの開始位置を見つける
+                end_pos = len(user_input)
+                for end_indicator in problem_indicators + example_indicators:
+                    pos = user_input.find(end_indicator, start_pos)
+                    if pos != -1 and pos < end_pos:
+                        end_pos = pos
+                
+                # 制約を抽出
+                constraint = user_input[start_pos:end_pos].strip()
+                if constraint:
+                    constraints.append(constraint)
+        
+        # 例の抽出と追加
+        examples = []
+        for indicator in example_indicators:
+            if indicator in user_input:
+                # 例の開始位置を見つける
+                start_pos = user_input.find(indicator) + len(indicator)
+                
+                # 次のセクションの開始位置を見つける
+                end_pos = len(user_input)
+                for end_indicator in problem_indicators + constraint_indicators:
+                    pos = user_input.find(end_indicator, start_pos)
+                    if pos != -1 and pos < end_pos:
+                        end_pos = pos
+                
+                # 例を抽出
+                example = user_input[start_pos:end_pos].strip()
+                if example:
+                    examples.append(example)
+        
+        # 問題記述を構築
+        full_description = problem_desc
+        
+        if constraints:
+            full_description += "\n\n制約条件:\n" + "\n".join(constraints)
+        
+        if examples:
+            full_description += "\n\n例:\n" + "\n".join(examples)
+        
+        return full_description
+
+    def _extract_problem_constraints(self, problem_description: str) -> List[str]:
+        """問題記述から特定の制約を抽出する"""
+        constraints = []
+        
+        # 一般的な制約パターン
+        constraint_patterns = [
+            (r'i\s*!=\s*j', "インデックスが異なる必要がある"),
+            (r'i\s*≠\s*j', "インデックスが異なる必要がある"),
+            (r'i\s*<>\s*j', "インデックスが異なる必要がある"),
+            (r'0\s*<=\s*\w+\s*<\s*n', "インデックスは配列の範囲内"),
+            (r'O\(n\)', "線形時間複雑度が要求される"),
+            (r'O\(n\s*log\s*n\)', "n log n の時間複雑度が要求される"),
+            (r'O\(1\)', "定数時間/空間が要求される"),
+            (r'空間複雑度.*O\(\w+\)', "特定の空間複雑度制約がある"),
+            (r'時間複雑度.*O\(\w+\)', "特定の時間複雑度制約がある"),
+            (r'メモリ使用量.*\d+[MG]B', "メモリ使用量制約がある"),
+            (r'実行時間.*\d+m?s', "実行時間制約がある"),
+            (r'入力.*\d+\s*<=\s*\w+\s*<=\s*\d+', "入力値の範囲制約がある")
+        ]
+        
+        # 特定のアルゴリズム/データ構造に関する制約
+        algorithm_patterns = [
+            (r'(?:使用|利用)(?:して|する)?.*(?:トライ|Trie)', "トライ木の使用が推奨/要求される"),
+            (r'(?:使用|利用)(?:して|する)?.*(?:動的計画法|DP)', "動的計画法の使用が推奨/要求される"),
+            (r'(?:使用|利用)(?:して|する)?.*(?:二分探索|バイナリサーチ)', "二分探索の使用が推奨/要求される"),
+            (r'(?:使用|利用)(?:して|する)?.*(?:BFS|幅優先探索)', "幅優先探索の使用が推奨/要求される"),
+            (r'(?:使用|利用)(?:して|する)?.*(?:DFS|深さ優先探索)', "深さ優先探索の使用が推奨/要求される"),
+            (r'(?:使用|利用)(?:して|する)?.*(?:ヒープ|優先度付きキュー)', "ヒープ/優先度付きキューの使用が推奨/要求される")
+        ]
+        
+        # 特定のトピックに関する制約（ビット操作、数学など）
+        topic_patterns = [
+            (r'ビット.*操作', "ビット操作の知識が必要"),
+            (r'XOR|ビット排他的論理和', "XOR操作の理解が必要"),
+            (r'mod(?:ulo)?.*10\^9\s*\+\s*7', "大きな数値に対するモジュロ演算が必要")
+        ]
+        
+        # 物理シミュレーション関連の制約パターン
+        physics_patterns = [
+            (r'(?:物理|力学).*シミュレーション', "物理シミュレーションの実装が必要"),
+            (r'(?:流体|流れ).*力学', "流体力学の知識と実装が必要"),
+            (r'(?:衝突|干渉).*検出', "衝突検出アルゴリズムが必要"),
+            (r'(?:剛体|弾性体).*運動', "剛体/弾性体運動の実装が必要"),
+            (r'(?:ニュートン|運動).*法則', "運動法則の正確な実装が必要"),
+            (r'(?:保存|エネルギー).*法則', "エネルギー保存法則の考慮が必要"),
+            (r'数値安定性', "数値計算の安定性への考慮が必要")
+        ]
+        
+        # 全てのパターンをチェック
+        all_patterns = constraint_patterns + algorithm_patterns + topic_patterns + physics_patterns
+        for pattern, description in all_patterns:
+            if re.search(pattern, problem_description, re.IGNORECASE):
+                constraints.append(description)
+        
+        return constraints
+
+    def _build_verification_prompt(self, language: str, code: str, user_input: str = None, design_doc: str = None) -> str:
+        """コード検証用のプロンプトを構築する（問題文も含める、OOP原則、ベクトル効率、無限ループ検出を強化）"""
+        # 問題記述の抽出
+        problem_description = None
+        problem_constraints = []
+        if user_input:
+            problem_description = self._extract_problem_description(user_input)
+            if problem_description:
+                problem_constraints = self._extract_problem_constraints(problem_description)
+    
+        # 制約条件の文字列化
+        constraints_str = ""
+        if problem_constraints:
+            constraints_str = "特に注意すべき制約条件:\n" + "\n".join([f"- {c}" for c in problem_constraints])
+    
+        # OOP設計原則項目の追加
+        oop_principles = """
+        オブジェクト指向設計原則:
+        - 単一責任の原則 (SRP): 各クラスは明確で単一の責任を持つべき
+        - 開放/閉鎖原則 (OCP): クラスは拡張に対しては開かれ、修正に対しては閉じられるべき
+        - リスコフの置換原則 (LSP): サブクラスはスーパークラスの代わりに使えるべき
+        - インターフェース分離の原則 (ISP): 具体的なクライアント向けに最小限のインターフェースを設計
+        - 依存関係逆転の原則 (DIP): 高レベルモジュールは低レベルモジュールに依存すべきでない
+        - 継承よりコンポジションを優先する
+        - 過剰な継承階層を避ける（3-4階層以内に抑える）
+        - 適切なカプセル化とアクセス修飾子の使用
+        """
+    
+        # ベクトル計算効率項目の追加
+        vector_efficiency = """
+        ベクトル計算の効率:
+        - 大規模ベクトル操作はループの代わりにベクトル化された操作を使用
+        - 不必要なコピーを最小限に抑え、参照渡しや変更可能なベクトル操作を適切に使用
+        - キャッシュ効率を考慮した連続したメモリアクセスパターン
+        - 適切なBLAS/LAPACKなどの最適化ライブラリの使用（該当する場合）
+        - ゼロコピー操作とスライス操作の適切な使用
+        - 次元削減とブロードキャスト操作の効率的な利用
+        - 並列化可能なベクトル操作の特定と実装
+        """
+    
+        # 無限ループ検出の強化
+        infinite_loop_detection = """
+        無限ループの詳細な検出項目:
+        1. 終了条件の欠如または到達不能な終了条件
+        2. ループカウンタの更新漏れまたは不適切な更新
+        3. 無効または変更されないループ条件変数
+        4. 再帰呼び出しの無限連鎖の可能性
+        5. イテレータ/インデックスの増減が条件に影響しない場合
+        6. 浮動小数点比較による終了条件の見落とし
+        7. コレクションを反復処理中にその構造を変更するケース
+        8. 複数の終了条件の論理的矛盾
+        9. 外部依存による終了条件（ファイル終端、ユーザー入力など）の信頼性
+        10. 入力値に依存した無限ループの可能性（入力範囲の検証）
+        """
+        
+        # 物理シミュレーション固有の検証項目
+        physics_simulation_validation = """
+        物理シミュレーションの検証項目:
+        1. 物理法則の正確な適用（エネルギー保存、運動量保存など）
+        2. 単位の一貫性（SI単位系など）
+        3. 数値積分法の安定性（オイラー法、ルンゲクッタ法など）
+        4. 境界条件の適切な処理
+        5. 外力と拘束条件の正確な実装
+        6. エッジケースでの安定性（極端な初期条件、衝突など）
+        7. 計算効率と精度のバランス
+        8. 確率的要素の適切な実装（乱数生成など）
+        """
+        
+        # エラーハンドリングの検証項目
+        error_handling_validation = """
+        エラーハンドリングの検証項目:
+        1. 例外の種類ごとの適切な捕捉と処理
+        2. エラーメッセージの具体性と有用性
+        3. リソースの適切な解放（ファイルハンドル、ネットワーク接続など）
+        4. エラー発生時のシステム状態の一貫性維持
+        5. 致命的でないエラーからの回復メカニズム
+        6. エラーログの詳細度と使いやすさ
+        7. ユーザーに表示するエラーメッセージの適切性
+        8. セキュリティに関連するエラー情報の適切な隠蔽
+        """
+        
+        # コードの完全性検証項目
+        code_completeness_validation = """
+        コードの完全性検証項目:
+        1. 未実装メソッド（pass文や空の実装）の検出
+        2. インポートの漏れや未使用インポートの検出
+        3. 宣言されているが未使用の変数やメソッドの識別
+        4. 不完全なエラーハンドリング（try-exceptブロックなど）
+        5. 未完成のコメント（TODO、FIXME、XXXなど）の検出
+        6. テストコードの網羅性（全機能をカバーしているか）
+        7. ドキュメンテーションの完全性（すべての公開APIにドキュメントがあるか）
+        8. 設定ファイルや環境変数の完全性
+        """
+
+        # 設計書の情報を追加
+        design_spec_str = ""
+        if design_doc:
+            design_spec_str = f"""
+            このコードは以下の設計書に基づいています。コードが設計書の要件と一致しているか確認してください：
+            
+            {design_doc}
+            """
+        
+        prompt = {
+            "role": "Code_Verifier_And_Algorithm_Expert",
+            "instruction": f"""あなたは{language}の専門家で、アルゴリズムとデータ構造に精通しています。
+            提供されたコードを厳密に検証し、問題固有の制約条件を考慮して評価してください。
+            
+            以下の観点でコードを検証し、JSON形式で結果を返してください:
+            
+            1. 構文エラーやコンパイルエラー
+            2. 論理的な誤りやアルゴリズムの欠陥
+            3. 問題の制約条件との整合性
+            4. エッジケース（空の入力、最小/最大値、重複など）の処理
+            5. 時間/空間複雑度の要件への適合
+            6. データ構造の実装不備（例: トライ木の不完全な接続、グラフの誤った表現）
+            7. 指定されたアルゴリズムの正しい実装（該当する場合）
+            8. メモリリークやリソース管理の問題
+            
+            特に重点的に検証すべき項目:
+            
+            1. 無限ループの可能性
+            {infinite_loop_detection}
+            
+            2. オブジェクト指向設計の原則（OOPコードの場合）
+            {oop_principles}
+            
+            3. ベクトル計算の効率性（ベクトル/行列操作を含む場合）
+            {vector_efficiency}
+            
+            4. 物理シミュレーションの正確性（物理シミュレーションの場合）
+            {physics_simulation_validation}
+            
+            5. エラーハンドリングの完全性
+            {error_handling_validation}
+            
+            6. コードの完全性と実行可能性
+            {code_completeness_validation}
+            
+            {design_spec_str}
+            
+            問題の説明:
+            {problem_description or "具体的な問題説明は提供されていません。一般的なコード品質を検証します。"}
+            
+            {constraints_str}
+            
+            応答は以下のJSON形式で返してください:
+            {{
+                "is_valid": boolean,  // コードが有効かどうか
+                "issues": [string],   // 検出された問題点のリスト（重要度順）
+                "design_compliance": boolean, // 設計書の要件に準拠しているか（設計書がある場合）
+                "missing_requirements": [string], // 設計書で定義されているが実装されていない要件（設計書がある場合）
+                "algorithm_analysis": string, // アルゴリズム分析（時間/空間複雑度など）
+                "edge_cases": [string], // テストすべきエッジケースのリスト
+                "oop_analysis": string, // OOP原則の遵守状況分析（該当する場合のみ）
+                "vector_efficiency_analysis": string, // ベクトル計算効率の分析（該当する場合のみ）
+                "physics_simulation_analysis": string, // 物理シミュレーションの分析（該当する場合のみ）
+                "error_handling_analysis": string, // エラーハンドリングの分析
+                "code_completeness_analysis": string, // コードの完全性分析
+                "infinite_loop_risk": {{
+                    "risk_level": string, // "none", "low", "medium", "high"のいずれか
+                    "potential_causes": [string], // 潜在的な無限ループの原因（リスクがある場合）
+                    "recommended_safeguards": [string] // 推奨される安全対策（リスクがある場合）
+                }},
+                "fixed_code": string, // 修正されたコード（問題がある場合のみ）
+                "explanation": string // 修正の詳細な説明（問題がある場合のみ）
+            }}
+            """,
+            "code_to_verify": code,
+            "language": language
+        }
+        
+        return json.dumps(prompt, ensure_ascii=False)
+
+    def _extract_design_doc(self, content: str) -> Optional[str]:
+        """コンテンツから設計書部分を抽出する"""
+        # 設計書の開始と終了を示す一般的なパターン
+        design_doc_indicators = [
+            "設計書", "要件の整理と分析", "アーキテクチャ設計", "詳細設計", 
+            "クラス/モジュール構造", "コンポーネント構成", "データモデル"
+        ]
+        
+        # コンテンツに設計書のパターンがあるか確認
+        for indicator in design_doc_indicators:
+            if indicator in content:
+                # 設計書全体を抽出
+                start_index = content.find(indicator)
+                design_doc = content[start_index:]
+                return design_doc
+        
+        return None
+
+    def _extract_class_definitions_from_design(self, design_doc: str) -> Dict[str, Dict[str, Any]]:
+        """設計書からクラス定義と要件を抽出する"""
+        class_definitions = {}
+        
+        # クラス定義の抽出
+        class_pattern = r'class\s+(\w+):'
+        class_matches = re.finditer(class_pattern, design_doc)
+        
+        for match in class_matches:
+            class_name = match.group(1)
+            # クラスの説明を抽出
+            start_pos = match.end()
+            next_class_match = re.search(r'class\s+\w+:', design_doc[start_pos:])
+            end_pos = start_pos + next_class_match.start() if next_class_match else len(design_doc)
+            class_body = design_doc[start_pos:end_pos].strip()
+            
+            # メソッド定義の抽出
+            method_pattern = r'def\s+(\w+)\s*\((.*?)\)'
+            method_matches = re.finditer(method_pattern, class_body)
+            methods = {}
+            
+            for method_match in method_matches:
+                method_name = method_match.group(1)
+                parameters = [p.strip() for p in method_match.group(2).split(',') if p.strip()]
+                methods[method_name] = parameters
+            
+            class_definitions[class_name] = {
+                "methods": methods,
+                "description": class_body
+            }
+        
+        return class_definitions
+
+    def _extract_requirements_from_design(self, design_doc: str) -> List[str]:
+        """設計書から機能要件を抽出する"""
+        requirements = []
+        
+        # 機能要件セクションの抽出
+        if "機能要件" in design_doc:
+            func_req_section = re.search(r'機能要件([\s\S]*?)(?=1\.2|非機能要件|$)', design_doc)
+            if func_req_section:
+                section_text = func_req_section.group(1)
+                # 箇条書きの抽出
+                bullet_pattern = r'[•*-]\s*(.*?)(?=$|\n)'
+                bullet_points = re.findall(bullet_pattern, section_text)
+                if bullet_points:
+                    requirements.extend(bullet_points)
+                else:
+                    # 番号付きリストの抽出
+                    numbered_pattern = r'\d+\.\s*(.*?)(?=$|\n)'
+                    numbered_points = re.findall(numbered_pattern, section_text)
+                    if numbered_points:
+                        requirements.extend(numbered_points)
+        
+        return requirements
+
+    def _check_implementation_against_design(self, code: str, design_doc: str) -> Dict[str, Any]:
+        """実装コードが設計書の要件に合致しているか確認する"""
+        result = {
+            "design_compliance": True,
+            "missing_requirements": [],
+            "missing_classes": [],
+            "missing_methods": []
+        }
+        
+        # クラス定義の抽出
+        class_definitions = self._extract_class_definitions_from_design(design_doc)
+        
+        # 要件の抽出
+        requirements = self._extract_requirements_from_design(design_doc)
+        
+        # 実装されたクラスの抽出
+        implemented_classes = re.findall(r'class\s+(\w+)', code)
+        
+        # クラスの確認
+        for class_name, class_info in class_definitions.items():
+            if class_name not in implemented_classes:
+                result["design_compliance"] = False
+                result["missing_classes"].append(class_name)
+                continue
+            
+            # メソッドの確認
+            class_code_match = re.search(fr'class\s+{class_name}[\s\S]*?(?:class|\Z)', code)
+            if class_code_match:
+                class_code = class_code_match.group(0)
+                for method_name in class_info["methods"]:
+                    method_pattern = fr'def\s+{method_name}\s*\('
+                    if not re.search(method_pattern, class_code):
+                        result["design_compliance"] = False
+                        result["missing_methods"].append(f"{class_name}.{method_name}")
+        
+        # 要件の確認
+        for req in requirements:
+            # キーワードベースの簡易チェック
+            keywords = self._extract_keywords(req)
+            if keywords and not all(re.search(fr'\b{re.escape(kw.lower())}\b', code.lower()) for kw in keywords if len(kw) > 3):
+                result["design_compliance"] = False
+                result["missing_requirements"].append(req)
+        
+        return result
+
+    def _extract_keywords(self, text: str) -> List[str]:
+        """テキストから重要なキーワードを抽出する"""
+        # ストップワードを定義
+        stop_words = {
+            "a", "an", "the", "this", "that", "these", "those", "and", "or", "but", "for", "nor", "so", "yet",
+            "を", "に", "は", "が", "で", "と", "から", "まで", "より", "して", "する", "ます", "です"
+        }
+        
+        # 単語に分割
+        words = re.findall(r'\b\w+\b', text.lower())
+        
+        # ストップワードと短す���る単語を除外
+        keywords = [w for w in words if w not in stop_words and len(w) > 1]
+        
+        return keywords
+
+    async def _verify_single_code_block(self, index: int, code_block: Dict[str, Any], user_input: str = None, design_doc: str = None) -> Dict[str, Any]:
+        """単一のコードブロックを検証する（ユーザー入力コンテキスト付き）"""
+        print(f"[Code Verification] Started verification of code block {index+1}")
+        
+        language = code_block.get("language", "unknown")
+        code = code_block.get("code", "")
+        
+        # 空のコードブロックや意味のない内容を検出
+        if not code.strip() or code.strip() in ["pass", "#", "# コード", "# Code"]:
+            return {
+                "block_info": {
+                    "block_index": index,
+                    "language": language,
+                    "is_valid": False,
+                    "issues": ["コードが提供されていないか、空です"],
+                    "algorithm_analysis": "コードが不足しています",
+                    "edge_cases": [],
+                    "was_fixed": False
+                },
+                "needs_update": False,
+                "fixed_code": code,
+                "explanation": "コードが提供されていません。適切なコードを実装してください。"
+            }
+        
+        # 検証プロンプトの構築（ユーザー入力と設計書を含める）
+        verification_prompt = self._build_verification_prompt(language, code, user_input, design_doc)
+        messages = [
+            {
+                "role": "system",
+                "content": verification_prompt
+            }
+        ]
+        
+        response = await self._make_async_api_call(
+            self.verify_model,
+            messages,
+            temperature=0.1,
+            response_format={"type": "json_object"}
+        )
+       
+        # 検証結果の解析
+        verification_result = json.loads(response.choices[0].message.content)
+       
+        # 結果をまとめる
+        needs_update = False
+        fixed_code = code
+       
+        if not verification_result.get("is_valid", True):
+            print(f"[Code Verification] Issues found in code block {index+1}")
+            if "fixed_code" in verification_result and verification_result["fixed_code"].strip():
+                fixed_code = verification_result["fixed_code"]
+                needs_update = code != fixed_code
+       
+        # 設計書の要件確認
+        design_compliance = verification_result.get("design_compliance", True)
+        missing_requirements = verification_result.get("missing_requirements", [])
+       
+        return {
+            "block_info": {
+                "block_index": index,
+                "language": language,
+                "is_valid": verification_result.get("is_valid", True),
+                "issues": verification_result.get("issues", []),
+                "algorithm_analysis": verification_result.get("algorithm_analysis", ""),
+                "edge_cases": verification_result.get("edge_cases", []),
+                "was_fixed": needs_update,
+                "design_compliance": design_compliance,
+                "missing_requirements": missing_requirements,
+                "physics_simulation_analysis": verification_result.get("physics_simulation_analysis", ""),
+                "error_handling_analysis": verification_result.get("error_handling_analysis", ""),
+                "code_completeness_analysis": verification_result.get("code_completeness_analysis", "")
+            },
+            "needs_update": needs_update,
+            "fixed_code": fixed_code,
+            "explanation": verification_result.get("explanation", "")
+        }
+
+    async def verify_code_blocks(self, content: str, user_input: str = None) -> Dict[str, Any]:
+        """コンテンツから抽出したコードブロックを並列検証する（設計書認識機能付き）"""
+        print("\n[Code Verification] Verifying code blocks in content...")
+       
+        # 設計書の検出と抽出
+        design_doc = self._extract_design_doc(content)
+        if design_doc:
+            print("[Code Verification] Design document detected")
+       
+        # コンテンツからコードブロックを抽出
+        code_blocks = self._extract_code_blocks(content)
+       
+        if not code_blocks:
+            print("[Code Verification] No code blocks found to verify")
+           
+            # 設計書があるが実装がない場合
+            if design_doc:
+                return {
+                    "verified_content": content,
+                    "verification_result": {
+                        "verified_code_blocks": [],
+                        "issues_found": True,
+                        "verification_summary": "設計書は見つかりましたが、実装コードがありません。設計書に基づいた実装が必要です。",
+                        "design_requirements": self._extract_requirements_from_design(design_doc)
+                    }
+                }
+           
+            return {
+                "verified_content": content,
+                "verification_result": {
+                    "verified_code_blocks": [],
+                    "issues_found": False,
+                    "verification_summary": "コードブロックが見つかりませんでした。"
+                }
+            }
+       
+        # 検証結果を格納する辞書
+        verification_results = {
+            "verified_code_blocks": [],
+            "issues_found": False,
+            "verification_summary": "",
+            "verification_time": 0,
+            "algorithm_issues": [],
+            "critical_edge_cases": [],
+            "design_compliance": True,
+            "missing_requirements": [],
+            "physics_simulation_issues": [],
+            "error_handling_issues": [],
+            "code_completeness_issues": []
+        }
+       
+        # 並列検証の開始時間を記録
+        start_time = asyncio.get_event_loop().time()
+       
+        # 各コードブロックの検証タスクを作成
+        verification_tasks = []
+        for i, code_block in enumerate(code_blocks):
+            task = self._verify_single_code_block(i, code_block, user_input, design_doc)
+            verification_tasks.append(task)
+       
+        # すべての検証タスクを並列実行
+        print(f"[Code Verification] Parallel verification of {len(verification_tasks)} code blocks started")
+        block_results = await asyncio.gather(*verification_tasks, return_exceptions=True)
+       
+        # 更新されたコンテンツ
+        verified_content = content
+       
+        # 設計書関連の問題を収集
+        design_issues = set()
+       
+        # 検証結果の処理
+        for i, result in enumerate(block_results):
+            if isinstance(result, Exception):
+                print(f"[Error] Verification of block {i} failed: {str(result)}")
+                verification_results["verified_code_blocks"].append({
+                    "block_index": i,
+                    "language": code_blocks[i].get("language", "unknown"),
+                    "verification_error": str(result)
+                })
+                continue
+               
+            # 結果を格納
+            verification_results["verified_code_blocks"].append(result["block_info"])
+           
+            # 設計書の遵守状況を確認
+            if not result["block_info"].get("design_compliance", True):
+                verification_results["design_compliance"] = False
+                missing_reqs = result["block_info"].get("missing_requirements", [])
+                for req in missing_reqs:
+                    design_issues.add(req)
+           
+            # アルゴリズム分析とエッジケースの収集
+            if result["block_info"].get("algorithm_analysis"):
+                verification_results["algorithm_issues"].append({
+                    "block_index": i,
+                    "analysis": result["block_info"]["algorithm_analysis"]
+                })
+           
+            if result["block_info"].get("edge_cases"):
+                verification_results["critical_edge_cases"].extend(result["block_info"]["edge_cases"])
+                
+            # 物理シミュレーション分析の収集
+            if result["block_info"].get("physics_simulation_analysis"):
+                verification_results["physics_simulation_issues"].append({
+                    "block_index": i,
+                    "analysis": result["block_info"]["physics_simulation_analysis"]
+                })
+                
+            # エラーハンドリング分析の収集
+            if result["block_info"].get("error_handling_analysis"):
+                verification_results["error_handling_issues"].append({
+                    "block_index": i,
+                    "analysis": result["block_info"]["error_handling_analysis"]
+                })
+                
+            # コード完全性分析の収集
+            if result["block_info"].get("code_completeness_analysis"):
+                verification_results["code_completeness_issues"].append({
+                    "block_index": i,
+                    "analysis": result["block_info"]["code_completeness_analysis"]
+                })
+           
+            # 問題が見つかった場合はコンテンツを更新
+            if result["needs_update"]:
+                verification_results["issues_found"] = True
+                verified_content = self._update_code_in_content(
+                    verified_content,
+                    i,
+                    result["fixed_code"]
+                )
+               
+                # 修正の説明も保存
+                if "explanation" in result and result["explanation"]:
+                    if "code_fixes_explanations" not in verification_results:
+                        verification_results["code_fixes_explanations"] = []
+                    verification_results["code_fixes_explanations"].append({
+                       "block_index": i,
+                       "explanation": result["explanation"]
+                    })
+       
+        # 検証時間を計算
+        end_time = asyncio.get_event_loop().time()
+        verification_time = end_time - start_time
+        verification_results["verification_time"] = round(verification_time, 2)
+       
+        # 重複するエッジケースを削除
+        verification_results["critical_edge_cases"] = list(set(verification_results["critical_edge_cases"]))
+       
+        # 設計書の要件を追加
+        if design_issues:
+            verification_results["missing_requirements"] = list(design_issues)
+       
+        # 検証サマリーの生成
+        if verification_results["issues_found"]:
+            verification_results["verification_summary"] = f"コードの問題が検出され修正されました（検証時間: {verification_results['verification_time']}秒）。\n\n"
+            
+            # 問題と修正内容のサマリーを対比形式で表示
+            for block in verification_results["verified_code_blocks"]:
+                if block.get("was_fixed", False):
+                    issues_list = block.get("issues", [])
+                    if issues_list:
+                        verification_results["verification_summary"] += f"ブロック{block['block_index']+1}({block['language']}):\n"
+                        for issue in issues_list[:3]:
+                            verification_results["verification_summary"] += f"❌ 問題: {issue}\n"
+                        verification_results["verification_summary"] += f"✅ 修正完了: コードが自動修正されました\n\n"
+            
+            # 設計書の要件未実装がある場合
+            if not verification_results["design_compliance"] and verification_results["missing_requirements"]:
+                verification_results["verification_summary"] += "\n設計書の要件に対する問題:\n"
+                for req in verification_results["missing_requirements"][:5]:
+                    verification_results["verification_summary"] += f"❌ 未実装: {req}\n"
+                if len(verification_results["missing_requirements"]) > 5:
+                    verification_results["verification_summary"] += "...他にも未実装の要件があります\n"
+                    
+            # 物理シミュレーション関連の問題がある場合
+            if verification_results["physics_simulation_issues"]:
+                verification_results["verification_summary"] += "\n物理シミュレーションの問題:\n"
+                for issue in verification_results["physics_simulation_issues"][:3]:
+                    verification_results["verification_summary"] += f"⚠️ {issue['analysis']}\n"
+                
+            # エラーハンドリング関連の問題がある場合
+            if verification_results["error_handling_issues"]:
+                verification_results["verification_summary"] += "\nエラーハンドリングの問題:\n"
+                for issue in verification_results["error_handling_issues"][:3]:
+                    verification_results["verification_summary"] += f"⚠️ {issue['analysis']}\n"
+                
+            # コード完全性関連の問題がある場合
+            if verification_results["code_completeness_issues"]:
+                verification_results["verification_summary"] += "\nコードの完全性に関する問題:\n"
+                for issue in verification_results["code_completeness_issues"][:3]:
+                    verification_results["verification_summary"] += f"⚠️ {issue['analysis']}\n"
+        else:
+            verification_results["verification_summary"] = f"✅ すべてのコードが検証を通過しました（検証時間: {verification_results['verification_time']}秒）。\n"
+            
+            # エッジケースの提案がある場合
+            if verification_results["critical_edge_cases"]:
+                verification_results["verification_summary"] += f"\n\nテスト推奨エッジケース: {', '.join(verification_results['critical_edge_cases'][:5])}"
+       
+        return {
+            "verified_content": verified_content,
+            "verification_result": verification_results
+        }
+
+    async def verify_implementation(self, technical_analysis, user_input: str = None) -> Dict[str, Any]:
+        """実装データを検証する（JSON形式または純粋なコンテンツ）"""
+        if isinstance(technical_analysis, dict):
+            # 辞書/JSON形式のデータが渡された場合
+            code_blocks = self._extract_nested_code_blocks(technical_analysis)
+           
+            if not code_blocks:
+                print("[Code Verification] No code blocks found in analysis")
+                return technical_analysis
+           
+            # 辞書の場合の検証コード��こちらに実装する
+            # 現在はコードの抽出のみ実装
+            return technical_analysis
+       
+        elif isinstance(technical_analysis, str):
+            # 文字列（マークダウンなど）の場合
+            result = await self.verify_code_blocks(technical_analysis, user_input)
+            return result["verified_content"]
+        else:
+            # その他の型の場合
+            print(f"[Error] Unsupported data type for verification: {type(technical_analysis)}")
+            return technical_analysis
+            
+    async def verify_implementation_completeness(self, code: str) -> Dict[str, Any]:
+        """コードの完全性を検証し、不足している部分を特定する"""
+        # 結果を格納する辞書
+        result = {
+            "is_complete": True,
+            "issues": [],
+            "unimplemented_methods": [],
+            "missing_imports": [],
+            "missing_error_handling": [],
+            "todos": []
+        }
+        
+        # 空のコード、空のメソッド、パスのみのメソッドを検出
+        if not code.strip():
+            result["is_complete"] = False
+            result["issues"].append("コードが空です")
+            return result
+            
+        try:
+            # ASTを使用してコードを解析
+            tree = ast.parse(code)
+            
+            # 未実装メソッドの検出
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef):
+                    # 関数本体の確認
+                    function_body = node.body
+                    
+                    # 空の関数や単なる'pass'のみの関数を検出
+                    if not function_body:
+                        result["is_complete"] = False
+                        result["unimplemented_methods"].append(node.name)
+                        result["issues"].append(f"未実装のメソッド: {node.name}")
+                    elif len(function_body) == 1 and isinstance(function_body[0], ast.Pass):
+                        result["is_complete"] = False
+                        result["unimplemented_methods"].append(node.name)
+                        result["issues"].append(f"未実装のメソッド (pass文のみ): {node.name}")
+                
+                # ToDo コメントの検出
+                if isinstance(node, ast.Expr) and isinstance(node.value, ast.Str):
+                    comment = node.value.s
+                    if any(marker in comment for marker in ["TODO", "FIXME", "XXX", "todo", "fixme"]):
+                        result["todos"].append(comment)
+                        result["issues"].append(f"TODOコメント: {comment}")
+            
+            # インポートの確認
+            imported_modules = set()
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for name in node.names:
+                        imported_modules.add(name.name)
+                elif isinstance(node, ast.ImportFrom):
+                    imported_modules.add(node.module)
+            
+            # 使用されているが明示的にインポートされていないモジュールを検出
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load):
+                    module_name = node.id
+                    # 標準ライブラリや組み込み関数は除外
+                    if (module_name not in imported_modules and 
+                        module_name not in dir(__builtins__) and
+                        not any(module_name.startswith(imp) for imp in imported_modules)):
+                        result["missing_imports"].append(module_name)
+                        result["issues"].append(f"使用されているが明示的にインポートされていないモジュール: {module_name}")
+            
+            # エラーハンドリングの確認
+            try_blocks = sum(1 for node in ast.walk(tree) if isinstance(node, ast.Try))
+            if try_blocks == 0:
+                result["missing_error_handling"].append("try-exceptブロックが見つかりません")
+                result["issues"].append("エラーハンドリングが不足しています (try-exceptブロックなし)")
+        
+        except SyntaxError as e:
+            result["is_complete"] = False
+            result["issues"].append(f"構文エラー: {str(e)}")
+        
+        # 実行可能性のテスト
+        try:
+            # 一時ファイルにコードを書き込む
+            with tempfile.NamedTemporaryFile(suffix='.py', delete=False) as temp_file:
+                temp_file_path = temp_file.name
+                temp_file.write(code.encode('utf-8'))
+            
+            # Pythonのコンパイルチェック（構文チェック）を実行
+            compile_result = subprocess.run(
+                ['python', '-m', 'py_compile', temp_file_path],
+                capture_output=True,
+                text=True
+            )
+            
+            # エラーがあれば記録
+            if compile_result.returncode != 0:
+                result["is_complete"] = False
+                result["issues"].append(f"コンパイルエラー: {compile_result.stderr}")
+        
+        except Exception as e:
+            result["issues"].append(f"コードの実行可能性テスト中にエラー: {str(e)}")
+        finally:
+            # 一時ファイルの削除
+            if 'temp_file_path' in locals():
+                try:
+                    os.remove(temp_file_path)
+                except:
+                    pass
+        
+        # 完全性の最終判定
+        result["is_complete"] = result["is_complete"] and not result["issues"]
+        
+        return result
+        
+    async def apply_verification_feedback(self, original_prompt: str, verification_result: Dict[str, Any]) -> str:
+        """検証結果を基に改善されたプロンプトを生成する"""
+        # 検証結果から重要な問題点を抽出
+        issues = []
+        if "verified_code_blocks" in verification_result:
+            for block in verification_result["verified_code_blocks"]:
+                if not block.get("is_valid", True):
+                    issues.extend(block.get("issues", []))
+        
+        # 設計要件との不一致
+        if not verification_result.get("design_compliance", True):
+            missing_reqs = verification_result.get("missing_requirements", [])
+            for req in missing_reqs:
+                issues.append(f"設計要件未実装: {req}")
+        
+        # エッジケース対応の不足
+        edge_cases = verification_result.get("critical_edge_cases", [])
+        if edge_cases:
+            issues.append(f"対応すべきエッジケース: {', '.join(edge_cases[:5])}")
+        
+        # 物理シミュレーション関連の問題
+        if "physics_simulation_issues" in verification_result and verification_result["physics_simulation_issues"]:
+            for issue in verification_result["physics_simulation_issues"][:3]:
+                issues.append(f"物理シミュレーションの問題: {issue.get('analysis', '')}")
+        
+        # エラーハンドリング関連の問題
+        if "error_handling_issues" in verification_result and verification_result["error_handling_issues"]:
+            for issue in verification_result["error_handling_issues"][:3]:
+                issues.append(f"エラーハンドリングの問題: {issue.get('analysis', '')}")
+        
+        # コード完全性関連の問題
+        if "code_completeness_issues" in verification_result and verification_result["code_completeness_issues"]:
+            for issue in verification_result["code_completeness_issues"][:3]:
+                issues.append(f"コード完全性の問題: {issue.get('analysis', '')}")
+        
+        # 問題点が見つからない場合は元のプロンプトを返す
+        if not issues:
+            return original_prompt
+        
+        # 問題点を含めた改善プロンプトを生成
+        improved_prompt = f"{original_prompt}\n\n前回の実装では以下の問題点がありました。これらを解決した実装を提供してください：\n"
+        for i, issue in enumerate(issues[:10]):  # 最大10個の問題を表示
+            improved_prompt += f"{i+1}. {issue}\n"
+        
+        if len(issues) > 10:
+            improved_prompt += f"他にも{len(issues)-10}個の問題があります。\n"
+        
+        improved_prompt += "\n特に以下の点に注意して実装してください：\n"
+        improved_prompt += "1. 全てのコードが実行可能であること\n"
+        improved_prompt += "2. エッジケース（極端な入力値、境界条件）に対応すること\n"
+        improved_prompt += "3. エラーハンドリングを徹底すること\n"
+        improved_prompt += "4. 設計書の全ての要件を実装すること\n"
+        
+        return improved_prompt