jarvis_core/evidence/
├── __init__.py
├── grader.py          # メインのグレーダー
├── levels.py          # EvidenceLevelのenum定義
├── patterns.py        # 検出パターン定義
└── <新モジュール>.py  # 新しく作成するモジュール

"""<研究タイプ>のエビデンスグレーダー"""
from dataclasses import dataclass
from typing import Optional
import re

from .levels import EvidenceLevel


@dataclass
class <Type>GradeResult:
    """グレーディング結果"""
    level: EvidenceLevel
    confidence: float  # 0.0-1.0
    reasoning: str
    matched_patterns: list[str]


class <Type>Grader:
    """<研究タイプ>のエビデンスレベルを判定するグレーダー
    
    CEBMエビデンスレベルに基づいて、論文のタイトルと
    アブストラクトから研究タイプを判定し、適切なレベルを返す。
    """

    # 検出パターン
    PATTERNS = {
        "pattern_name": [
            r"正規表現パターン1",
            r"正規表現パターン2",
        ],
    }

    def __init__(self, use_llm: bool = False):
        """初期化
        
        Args:
            use_llm: LLMを使用した高精度判定を行うかどうか
        """
        self.use_llm = use_llm

    def grade(self, title: str, abstract: str) -> <Type>GradeResult:
        """エビデンスレベルを判定する
        
        Args:
            title: 論文タイトル
            abstract: アブストラクト
            
        Returns:
            グレーディング結果
        """
        text = f"{title} {abstract}".lower()
        matched = self._find_patterns(text)
        
        level = self._determine_level(matched)
        confidence = self._calculate_confidence(matched)
        reasoning = self._generate_reasoning(matched, level)
        
        return <Type>GradeResult(
            level=level,
            confidence=confidence,
            reasoning=reasoning,
            matched_patterns=matched,
        )

    def _find_patterns(self, text: str) -> list[str]:
        """パターンマッチングを実行"""
        matched = []
        for name, patterns in self.PATTERNS.items():
            for pattern in patterns:
                if re.search(pattern, text, re.IGNORECASE):
                    matched.append(name)
                    break
        return matched

    def _determine_level(self, matched: list[str]) -> EvidenceLevel:
        """マッチしたパターンからレベルを決定"""
        # 実装: マッチしたパターンに基づいてレベルを返す
        raise NotImplementedError

    def _calculate_confidence(self, matched: list[str]) -> float:
        """信頼度スコアを計算"""
        if not matched:
            return 0.0
        # マッチしたパターン数に基づいて信頼度を計算
        return min(len(matched) * 0.3, 1.0)

    def _generate_reasoning(self, matched: list[str], level: EvidenceLevel) -> str:
        """判定理由を生成"""
        if not matched:
            return "No matching patterns found"
        return f"Matched patterns: {', '.join(matched)} -> {level.value}"

"""<新モジュール>のテスト"""
import pytest
from jarvis_core.evidence.<新モジュール> import <Type>Grader
from jarvis_core.evidence.levels import EvidenceLevel


class Test<Type>Grader:
    """<Type>Graderのテスト"""

    @pytest.fixture
    def grader(self):
        return <Type>Grader()

    def test_grade_典型的な入力_正しいレベル(self, grader):
        """典型的な入力で正しいレベルを返す"""
        result = grader.grade(
            title="典型的なタイトル",
            abstract="典型的なアブストラクト"
        )
        assert result.level == EvidenceLevel.LEVEL_XX

    def test_grade_パターンなし_レベル5(self, grader):
        """パターンにマッチしない場合はレベル5を返す"""
        result = grader.grade(
            title="Generic title",
            abstract="Generic abstract"
        )
        assert result.level == EvidenceLevel.LEVEL_5

from .<新モジュール> import <Type>Grader, <Type>GradeResult

__all__ = [
    # 既存のエクスポート...
    "<Type>Grader",
    "<Type>GradeResult",
]