# ===== 正確性チェック =====
correctness_checklist = [
    "ビジネスロジックが要件と一致しているか",
    "エッジケース（null、空配列、0、負数、最大値）が処理されているか",
    "エラーハンドリングが適切か（例外の種類、リカバリー）",
    "並行処理の問題はないか（レースコンディション、デッドロック）",
    "トランザクション境界は正しいか",
    "既存テストが通るか（回帰がないか）",
    "整数オーバーフロー、浮動小数点の丸め誤差は考慮されているか",
    "タイムゾーン・日付境界の処理は正しいか",
]
 
# ===== 可読性チェック =====
readability_checklist = [
    "変数名・関数名が意図を明確に伝えているか",
    "関数の長さは適切か（20行以内が目安）",
    "ネストが深すぎないか（3段以内が目安）",
    "コメントが「なぜ」を説明しているか（「何」はコードが語るべき）",
    "一貫した命名規則に従っているか",
    "不要なコメントやデッドコードがないか",
    "認知負荷が高くないか（1つの関数で複数の抽象レベルを混在させていないか）",
    "早期リターンパターンが使えるのに深いネストになっていないか",
]
 
# ===== 保守性チェック =====
maintainability_checklist = [
    "単一責任原則に従っているか（1クラス=1責務）",
    "DRY原則：重複コードはないか",
    "テストが追加されているか（新機能・バグ修正）",
    "既存のアーキテクチャパターンに従っているか",
    "依存関係の方向は正しいか（レイヤー違反がないか）",
    "マジックナンバーが定数化されているか",
    "将来の変更が予想される箇所に適切な抽象化があるか",
    "設定値がハードコードされていないか（環境変数・設定ファイル）",
]
 
# ===== セキュリティチェック =====
security_checklist = [
    "入力のバリデーション・サニタイズは適切か",
    "SQLインジェクション対策（パラメータバインド）",
    "XSS対策（出力エスケープ）",
    "認証・認可チェックが漏れていないか",
    "機密情報がログに出力されていないか",
    "秘密鍵・トークンがコードにハードコードされていないか",
    "CSRF対策は適切か",
    "ファイルアップロードのサイズ制限・タイプチェックは適切か",
    "レート制限は適切に設定されているか",
]
 
# ===== パフォーマンスチェック =====
performance_checklist = [
    "N+1 クエリ問題はないか",
    "不要なデータの取得（SELECT *）はないか",
    "ループ内でのDB/API呼び出しはないか",
    "適切なインデックスが設定されているか",
    "大量データ処理でメモリを圧迫しないか",
    "キャッシュすべきデータをキャッシュしているか",
    "不要な再レンダリング（React）がないか",
    "非同期処理にすべき重い処理が同期で実行されていないか",
]

# セルフレビューチェックリスト
# PR 作成後、レビュー依頼前に作者自身が確認する
 
self_review_checklist = {
    "デバッグコード": [
        "print / console.log / debugger が残っていないか",
        "TODO / FIXME / HACK コメントが意図的か確認",
        "テスト用のハードコード値が残っていないか",
    ],
    "差分の確認": [
        "不要な変更（フォーマットのみの差分）が混ざっていないか",
        "意図しないファイルが含まれていないか (.env, node_modules)",
        "コミットメッセージは変更内容を正確に反映しているか",
    ],
    "テスト": [
        "新機能にテストを追加したか",
        "バグ修正に回帰テストを追加したか",
        "テストが他のテストに依存していないか（独立性）",
    ],
    "ドキュメント": [
        "公開 API の変更にドキュメント更新は必要か",
        "README や CHANGELOG の更新は必要か",
        "コメントが最新の実装と一致しているか",
    ],
}
 
# 研究結果: セルフレビューで指摘事項の30-40%は事前に除去できる

# レビューの効率的な時間配分
review_time_guide = {
    "small_pr":   {"lines": "< 100",   "time": "15分以内"},
    "medium_pr":  {"lines": "100-300",  "time": "30分以内"},
    "large_pr":   {"lines": "300-500",  "time": "60分以内"},
    "too_large":  {"lines": "> 500",    "time": "分割を依頼"},
}
 
# レスポンスタイム SLA
response_sla = {
    "initial_review":  "24時間以内",    # 最初のレビュー
    "re_review":       "8時間以内",     # 修正後の再レビュー
    "urgent_hotfix":   "2時間以内",     # 緊急修正
    "documentation":   "48時間以内",    # ドキュメントのみの変更
}
 
# レビュー効率を上げるための環境設定
review_setup = {
    "通知設定": "Slack/Teams に PR 通知を設定",
    "時間ブロック": "毎日30分のレビュー専用時間を確保",
    "バッチ処理": "小さな PR は2-3件まとめてレビュー",
    "コンテキスト切替最小化": "深い作業の合間ではなく、切りの良いタイミングで",
}

# BAD: 否定だけのコメント
# 「このコードは読みにくいです」
# 「なんでこう書いたんですか？」
 
# GOOD: 問題の特定 + 理由 + 具体的な改善案
 
# ===== パターン1: Before/After で提示 =====
 
# [SHOULD] ネストが深くなっています。
# 早期リターンパターンに変更すると可読性が向上します：
#
# Before:
def process(order):
    if order:
        if order.is_valid():
            if order.items:
                # 処理...
                pass
 
# Suggested:
def process(order):
    if not order:
        return
    if not order.is_valid():
        raise ValueError("Invalid order")
    if not order.items:
        raise ValueError("Empty items")
    # 処理...
 
# ===== パターン2: 理由を添えて提案 =====
 
# [SHOULD] このループ内で DB アクセスが発生しており、
# N+1 問題になっています。
# items が100件ある場合、100回のクエリが発行されます。
#
# 改善案: バッチクエリに変更
# Before:
for item in items:
    product = db.get_product(item.product_id)  # N回クエリ
 
# Suggested:
product_ids = [item.product_id for item in items]
products = db.get_products_by_ids(product_ids)  # 1回のクエリ
product_map = {p.id: p for p in products}
 
# ===== パターン3: トレードオフを示して議論を促す =====
 
# [DISCUSS] ここでキャッシュを導入すべきか検討が必要です。
# メリット: レスポンスが約10倍高速化（DB round-trip 削減）
# デメリット: キャッシュ無効化の複雑さが増加
# 現在のトラフィック量を考えると、今は不要かもしれません。
# どう思いますか？

# GitHub の Suggestion 構文で直接修正を提案
 
# レビューコメントで以下のように書く:
#
# [NIT] 定数名は UPPER_SNAKE_CASE にしましょう。
#
# ```suggestion
# MAX_RETRY_COUNT = 3
# TIMEOUT_SECONDS = 30
# ```
#
# → 作者はワンクリックで適用可能
 
# 複数行の提案も可能:
#
# [SHOULD] 型ヒントを追加しましょう。
#
# ```suggestion
# def calculate_total(
#     items: list[OrderItem],
#     tax_rate: float = 0.10,
# ) -> int:
# ```
 
# バッチ提案: 複数の suggestion をまとめて適用可能
# → 小さな修正を1コミットにまとめられる

# .github/workflows/pr-checks.yml
name: PR Checks
 
on:
  pull_request:
    branches: [main, develop]
 
jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Lint Check
        run: |
          ruff check .        # Python
          ruff format --check . # フォーマットチェック
 
  type-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Type Check
        run: mypy src/ --strict
 
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Tests
        run: pytest --cov=src --cov-report=xml --cov-fail-under=80
 
  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Security Scan
        run: |
          bandit -r src/       # Python セキュリティ
          pip-audit            # 依存関係の脆弱性
 
  pr-size:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Check PR Size
        run: |
          CHANGED_LINES=$(git diff --stat origin/main...HEAD | tail -1 | awk '{print $4}')
          if [ "$CHANGED_LINES" -gt 400 ]; then
            echo "::warning::PR が400行を超えています。分割を検討してください。"
          fi

# GitHub API を使ったレビューメトリクスの収集
 
import requests
from datetime import datetime, timedelta
from collections import defaultdict
 
def collect_review_metrics(repo: str, token: str, days: int = 30):
    """過去N日間のレビューメトリクスを収集"""
    headers = {"Authorization": f"Bearer {token}"}
    since = (datetime.now() - timedelta(days=days)).isoformat()
 
    # PRの取得
    prs = requests.get(
        f"https://api.github.com/repos/{repo}/pulls",
        headers=headers,
        params={"state": "closed", "since": since, "per_page": 100},
    ).json()
 
    metrics = {
        "total_prs": len(prs),
        "avg_time_to_first_review": [],
        "avg_cycle_time": [],
        "avg_comments_per_pr": [],
        "pr_sizes": [],
        "reviewer_load": defaultdict(int),
    }
 
    for pr in prs:
        # PR作成日時
        created_at = datetime.fromisoformat(pr["created_at"].replace("Z", "+00:00"))
        merged_at = pr.get("merged_at")
 
        if merged_at:
            merged_at = datetime.fromisoformat(merged_at.replace("Z", "+00:00"))
            cycle_time = (merged_at - created_at).total_seconds() / 3600
            metrics["avg_cycle_time"].append(cycle_time)
 
        # レビューの取得
        reviews = requests.get(
            pr["url"] + "/reviews",
            headers=headers,
        ).json()
 
        if reviews:
            first_review = datetime.fromisoformat(
                reviews[0]["submitted_at"].replace("Z", "+00:00")
            )
            time_to_first = (first_review - created_at).total_seconds() / 3600
            metrics["avg_time_to_first_review"].append(time_to_first)
 
            for review in reviews:
                reviewer = review["user"]["login"]
                metrics["reviewer_load"][reviewer] += 1
 
        # コメント数
        comments = requests.get(pr["url"] + "/comments", headers=headers).json()
        metrics["avg_comments_per_pr"].append(len(comments))
 
        # PR サイズ
        metrics["pr_sizes"].append(pr.get("additions", 0) + pr.get("deletions", 0))
 
    # 集計
    return {
        "total_prs": metrics["total_prs"],
        "avg_time_to_first_review_hours": (
            sum(metrics["avg_time_to_first_review"])
            / len(metrics["avg_time_to_first_review"])
            if metrics["avg_time_to_first_review"] else 0
        ),
        "avg_cycle_time_hours": (
            sum(metrics["avg_cycle_time"])
            / len(metrics["avg_cycle_time"])
            if metrics["avg_cycle_time"] else 0
        ),
        "avg_comments_per_pr": (
            sum(metrics["avg_comments_per_pr"])
            / len(metrics["avg_comments_per_pr"])
            if metrics["avg_comments_per_pr"] else 0
        ),
        "median_pr_size": sorted(metrics["pr_sizes"])[len(metrics["pr_sizes"]) // 2]
            if metrics["pr_sizes"] else 0,
        "reviewer_load": dict(metrics["reviewer_load"]),
    }

# レビュー対象コード
import json
import os
 
def get_users(db, role, page):
    query = f"SELECT * FROM users WHERE role = '{role}' ORDER BY id LIMIT 20 OFFSET {page * 20}"
    users = db.execute(query)
    result = []
    for u in users:
        if u.active == True:
            data = {}
            data['id'] = u.id
            data['name'] = u.first_name + ' ' + u.last_name
            data['email'] = u.email
            data['role'] = u.role
            data['created'] = str(u.created_at)
            data['password_hash'] = u.password_hash  # フロントエンドが必要としている
            result.append(data)
    return json.dumps(result)

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# チーム間のAPI契約定義
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
 
class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"
 
@dataclass
class APIContract:
    """チーム間のAPI契約"""
    endpoint: str
    method: str
    owner_team: str
    consumers: List[str]
    sla_ms: int  # レスポンスタイムSLA
    priority: Priority
 
    def validate_sla(self, actual_ms: int) -> bool:
        """SLA準拠の確認"""
        return actual_ms <= self.sla_ms
 
    def to_openapi(self) -> dict:
        """OpenAPI形式で出力"""
        return {
            'path': self.endpoint,
            'method': self.method,
            'x-owner': self.owner_team,
            'x-consumers': self.consumers,
            'x-sla-ms': self.sla_ms
        }
 
# 使用例
contracts = [
    APIContract(
        endpoint="/api/v1/users",
        method="GET",
        owner_team="user-team",
        consumers=["order-team", "notification-team"],
        sla_ms=200,
        priority=Priority.HIGH
    ),
    APIContract(
        endpoint="/api/v1/orders",
        method="POST",
        owner_team="order-team",
        consumers=["payment-team", "inventory-team"],
        sla_ms=500,
        priority=Priority.CRITICAL
    )
]

# セキュアコーディング例
import hashlib
import secrets
import hmac
from typing import Optional
 
class SecurityUtils:
    """セキュリティユーティリティ"""
 
    @staticmethod
    def generate_token(length: int = 32) -> str:
        """暗号学的に安全なトークン生成"""
        return secrets.token_urlsafe(length)
 
    @staticmethod
    def hash_password(password: str, salt: Optional[str] = None) -> tuple:
        """パスワードのハッシュ化"""
        if salt is None:
            salt = secrets.token_hex(16)
        hashed = hashlib.pbkdf2_hmac(
            'sha256',
            password.encode('utf-8'),
            salt.encode('utf-8'),
            iterations=100000
        )
        return hashed.hex(), salt
 
    @staticmethod
    def verify_password(password: str, hashed: str, salt: str) -> bool:
        """パスワードの検証"""
        new_hash, _ = SecurityUtils.hash_password(password, salt)
        return hmac.compare_digest(new_hash, hashed)
 
    @staticmethod
    def sanitize_input(value: str) -> str:
        """入力値のサニタイズ"""
        dangerous_chars = ['<', '>', '"', "'", '&', '\\']
        result = value
        for char in dangerous_chars:
            result = result.replace(char, '')
        return result.strip()
 
# 使用例
token = SecurityUtils.generate_token()
hashed, salt = SecurityUtils.hash_password("my_password")
is_valid = SecurityUtils.verify_password("my_password", hashed, salt)

# マイグレーションスクリプトのテンプレート
import json
import logging
from pathlib import Path
from datetime import datetime
from typing import List, Dict, Callable
 
logger = logging.getLogger(__name__)
 
class MigrationRunner:
    """段階的マイグレーション実行エンジン"""
 
    def __init__(self, migration_dir: str):
        self.migration_dir = Path(migration_dir)
        self.migrations: List[Dict] = []
        self.completed: List[str] = []
 
    def register(self, version: str, description: str,
                 up: Callable, down: Callable):
        """マイグレーションの登録"""
        self.migrations.append({
            'version': version,
            'description': description,
            'up': up,
            'down': down,
            'registered_at': datetime.now().isoformat()
        })
 
    def run_up(self, target_version: str = None):
        """マイグレーションの実行（アップグレード）"""
        for migration in self.migrations:
            if migration['version'] in self.completed:
                continue
            logger.info(f"実行中: {migration['version']} - "
                       f"{migration['description']}")
            try:
                migration['up']()
                self.completed.append(migration['version'])
                logger.info(f"完了: {migration['version']}")
            except Exception as e:
                logger.error(f"失敗: {migration['version']}: {e}")
                raise
            if target_version and migration['version'] == target_version:
                break
 
    def run_down(self, target_version: str):
        """マイグレーションのロールバック"""
        for migration in reversed(self.migrations):
            if migration['version'] not in self.completed:
                continue
            if migration['version'] == target_version:
                break
            logger.info(f"ロールバック: {migration['version']}")
            migration['down']()
            self.completed.remove(migration['version'])
 
    def status(self) -> Dict:
        """マイグレーション状態の確認"""
        return {
            'total': len(self.migrations),
            'completed': len(self.completed),
            'pending': len(self.migrations) - len(self.completed),
            'versions': {
                m['version']: 'completed'
                if m['version'] in self.completed else 'pending'
                for m in self.migrations
            }
        }