#!/bin/bash
# scripts/onboarding-setup.sh
# 新メンバーの開発環境を自動構築するスクリプト
 
set -euo pipefail
 
echo "=== AI時代の開発環境セットアップ ==="
echo ""
 
# 1. 基本開発ツール
echo "[1/5] 基本開発ツールのインストール..."
if [[ "$OSTYPE" == "darwin"* ]]; then
    # macOS
    command -v brew >/dev/null || /bin/bash -c \
        "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
    brew install git node python@3.12 docker
elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
    sudo apt update && sudo apt install -y git nodejs python3 docker.io
fi
 
# 2. AIコーディングツール
echo "[2/5] AIコーディングツールの設定..."
 
# GitHub Copilot (VS Code拡張)
code --install-extension GitHub.copilot
code --install-extension GitHub.copilot-chat
 
# Claude Code CLI
npm install -g @anthropic-ai/claude-code
 
# Cursor IDE (オプション)
if [[ "$INSTALL_CURSOR" == "true" ]]; then
    echo "Cursor IDEをインストール..."
    # プラットフォーム別インストール
fi
 
# 3. プロジェクト固有の設定
echo "[3/5] プロジェクト設定の適用..."
git clone "$PROJECT_REPO" ~/workspace/project
cd ~/workspace/project
 
# AIツール設定ファイルのコピー
cp .ai/configs/recommended-settings.json ~/.config/ai-tools/
 
# 4. AIプロンプトライブラリの設定
echo "[4/5] プロンプトライブラリの設定..."
mkdir -p ~/.ai/prompts
ln -sf ~/workspace/project/.ai/prompts ~/.ai/prompts/project
 
# 5. 検証
echo "[5/5] 環境を検証中..."
python3 -c "print('Python OK')"
node -e "console.log('Node OK')"
git --version
echo ""
echo "=== セットアップ完了 ==="
echo "次のステップ: docs/onboarding/phase1-checklist.md を確認してください"

// .ai/configs/recommended-settings.json
{
  "copilot": {
    "enable": true,
    "inlineSuggest.enable": true,
    "advanced": {
      "length": 500,
      "temperature": 0.1,
      "top_p": 0.95
    }
  },
  "claude_code": {
    "model": "claude-sonnet-4-20250514",
    "allowed_tools": ["Read", "Write", "Edit", "Bash", "Grep", "Glob"],
    "project_context": ".claude/CLAUDE.md"
  },
  "team_rules": {
    "ai_review_required": true,
    "max_ai_generated_without_test": 50,
    "sensitive_dirs_no_ai": ["src/auth/", "src/crypto/", "config/secrets/"],
    "prompt_template_required": true
  }
}

# onboarding/codebase_explorer.py
# 新メンバー向けAIコードベース探索ツール
 
from pathlib import Path
import json
 
class CodebaseExplorer:
    """新メンバーがAIを使ってコードベースを探索するためのガイド"""
 
    EXPLORATION_TASKS = [
        {
            "title": "アーキテクチャ概要の把握",
            "prompt": """
このプロジェクトのディレクトリ構成を分析し、
以下を説明してください：
1. 全体のアーキテクチャパターン（MVC, Clean Architecture等）
2. 主要なモジュールとその役割
3. データの流れ（リクエストからレスポンスまで）
4. 外部依存関係
""",
            "target": "プロジェクトルート",
            "estimated_time": "30分",
        },
        {
            "title": "ドメインモデルの理解",
            "prompt": """
このプロジェクトの主要なドメインモデル（エンティティ）を
一覧化し、それぞれの関係を説明してください：
1. 各モデルの属性と責務
2. モデル間のリレーション（1:N, N:M等）
3. ビジネスルールの実装場所
""",
            "target": "src/models/ or src/domain/",
            "estimated_time": "45分",
        },
        {
            "title": "API仕様の把握",
            "prompt": """
このプロジェクトのAPI一覧を分析し、
以下を整理してください：
1. エンドポイント一覧（メソッド, パス, 概要）
2. 認証・認可の仕組み
3. エラーハンドリングのパターン
4. レスポンス形式の規約
""",
            "target": "src/routes/ or src/controllers/",
            "estimated_time": "30分",
        },
        {
            "title": "テスト戦略の理解",
            "prompt": """
このプロジェクトのテスト戦略を分析してください：
1. テストの種類（ユニット/統合/E2E）と配置
2. テストフレームワークとその設定
3. モック/スタブの使い方
4. テストカバレッジの状況
""",
            "target": "tests/ or __tests__/",
            "estimated_time": "30分",
        },
    ]
 
    @classmethod
    def generate_exploration_plan(cls, project_path: str) -> str:
        """探索プランを生成"""
        plan = "# AIコードベース探索プラン\n\n"
        plan += f"プロジェクト: {project_path}\n\n"
 
        for i, task in enumerate(cls.EXPLORATION_TASKS, 1):
            plan += f"## タスク {i}: {task['title']}\n\n"
            plan += f"**対象**: `{task['target']}`\n"
            plan += f"**想定時間**: {task['estimated_time']}\n\n"
            plan += f"**AIへのプロンプト**:\n```\n{task['prompt'].strip()}\n```\n\n"
            plan += "**理解度チェック**:\n"
            plan += "- [ ] 自分の言葉で説明できる\n"
            plan += "- [ ] 関連コードの場所を指摘できる\n"
            plan += "- [ ] 改善点を1つ以上挙げられる\n\n"
 
        return plan

<!-- .ai/onboarding/understanding-check.md -->
# コードベース理解度チェックシート
 
## 回答者: ___
## 日付: ___
 
### アーキテクチャ
1. このプロジェクトのアーキテクチャパターンは何ですか？
   - 回答:
   - AIに確認した結果:
 
2. リクエストがDBに到達するまでの経路を説明してください。
   - 回答:
   - 通過するファイル/クラス:
 
### ドメイン知識
3. 主要なエンティティを3つ挙げ、関係を説明してください。
   - 回答:
 
4. 最も複雑なビジネスルールはどこに実装されていますか？
   - 回答:
   - ファイルパス:
 
### 開発フロー
5. 新機能を追加する場合の手順を説明してください。
   - 回答:
 
6. AIツールをどのように活用しますか？
   - 回答:
 
### メンターコメント
- 理解度: ☆☆☆☆☆ (5段階)
- 追加学習が必要な領域:
- 次のステップ:

# onboarding/prompt_training.py
# プロンプト設計の研修モジュール
 
class PromptTraining:
    """プロンプトエンジニアリングの段階的研修"""
 
    LEVELS = {
        "level_1_basic": {
            "title": "基本: 明確な指示",
            "principle": "具体的に、明確に、1つずつ依頼する",
            "bad_example": "このコードを直して",
            "good_example": (
                "以下のPython関数にある無限ループのバグを修正してください。\n"
                "修正後のコードと、何を変更したかの説明を含めてください。\n\n"
                "```python\ndef process_items(items):\n"
                "    i = 0\n    while i < len(items):\n"
                "        if items[i].is_valid():\n"
                "            handle(items[i])\n"
                "        # i += 1 が抜けている\n```"
            ),
            "exercise": "チームのバグレポートからAIに修正を依頼するプロンプトを書く",
        },
        "level_2_context": {
            "title": "中級: コンテキストの提供",
            "principle": "背景、制約、期待する形式を明示する",
            "bad_example": "テストを書いて",
            "good_example": (
                "以下の仕様に基づいてユニットテストを書いてください。\n\n"
                "## テスト対象\n"
                "UserService.create_user(name, email) メソッド\n\n"
                "## 仕様\n"
                "- nameは1-50文字の文字列\n"
                "- emailは有効なメールアドレス形式\n"
                "- 重複emailはエラー\n\n"
                "## テストフレームワーク\n"
                "pytest + pytest-mock\n\n"
                "## テストパターン\n"
                "正常系2つ、異常系3つ以上を含めてください"
            ),
            "exercise": "既存のテストファイルを参考に、新機能のテストプロンプトを作成",
        },
        "level_3_advanced": {
            "title": "上級: 思考の誘導",
            "principle": "段階的な推論、制約の明示、自己検証を組み込む",
            "bad_example": "パフォーマンスを改善して",
            "good_example": (
                "以下のAPIエンドポイントのレスポンスタイムが遅い問題を分析してください。\n\n"
                "## 手順\n"
                "1. まず、このコードのボトルネックになりうる箇所を3つ挙げてください\n"
                "2. 各ボトルネックの影響度を高/中/低で評価してください\n"
                "3. 最も影響度の高い箇所から、具体的な改善案を提示してください\n"
                "4. 各改善案のトレードオフ（メモリ使用量、コード複雑度等）も説明してください\n\n"
                "## 制約\n"
                "- 外部ライブラリの追加は不可\n"
                "- APIの互換性を維持すること\n"
                "- テストが通ること"
            ),
            "exercise": "本番障害シナリオでAIにデバッグを依頼するプロンプトを設計",
        },
    }
 
    @classmethod
    def get_curriculum(cls) -> str:
        """カリキュラムを出力"""
        output = "# プロンプトエンジニアリング研修\n\n"
        for level_id, level in cls.LEVELS.items():
            output += f"## {level['title']}\n\n"
            output += f"**原則**: {level['principle']}\n\n"
            output += f"**悪い例**:\n```\n{level['bad_example']}\n```\n\n"
            output += f"**良い例**:\n```\n{level['good_example']}\n```\n\n"
            output += f"**演習**: {level['exercise']}\n\n---\n\n"
        return output

# knowledge/knowledge_base.py
# チームナレッジベースの管理システム
 
import json
from datetime import datetime
from pathlib import Path
from dataclasses import dataclass, field, asdict
from typing import Optional
 
@dataclass
class KnowledgeEntry:
    """ナレッジエントリ"""
    id: str
    title: str
    category: str          # architecture, debugging, workflow, domain, tool
    content: str
    tags: list[str]
    author: str
    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
    updated_at: str = ""
    related_files: list[str] = field(default_factory=list)
    ai_generated: bool = False
    verified: bool = False
 
class TeamKnowledgeBase:
    """チームナレッジベースの管理"""
 
    CATEGORIES = [
        "architecture",   # アーキテクチャの意思決定
        "debugging",      # デバッグのノウハウ
        "workflow",       # 開発ワークフロー
        "domain",         # ドメイン知識
        "tool",           # ツール活用法
        "ai-prompt",      # 効果的なプロンプト
        "postmortem",     # 障害振り返り
    ]
 
    def __init__(self, base_dir: str = ".knowledge"):
        self.base_dir = Path(base_dir)
        self.base_dir.mkdir(parents=True, exist_ok=True)
 
    def add_entry(self, entry: KnowledgeEntry) -> str:
        """ナレッジを追加"""
        category_dir = self.base_dir / entry.category
        category_dir.mkdir(exist_ok=True)
 
        path = category_dir / f"{entry.id}.json"
        with open(path, "w") as f:
            json.dump(asdict(entry), f, indent=2, ensure_ascii=False)
 
        return str(path)
 
    def search(
        self,
        query: str,
        category: Optional[str] = None,
        tags: Optional[list[str]] = None,
    ) -> list[KnowledgeEntry]:
        """ナレッジを検索"""
        results = []
        search_dirs = (
            [self.base_dir / category] if category
            else [self.base_dir / c for c in self.CATEGORIES]
        )
 
        query_lower = query.lower()
        for search_dir in search_dirs:
            if not search_dir.exists():
                continue
            for path in search_dir.glob("*.json"):
                with open(path) as f:
                    data = json.load(f)
 
                # テキストマッチ
                text = f"{data['title']} {data['content']} {' '.join(data['tags'])}".lower()
                if query_lower not in text:
                    continue
 
                # タグフィルタ
                if tags and not set(tags).intersection(set(data["tags"])):
                    continue
 
                results.append(KnowledgeEntry(**data))
 
        return sorted(results, key=lambda e: e.created_at, reverse=True)
 
    def generate_onboarding_digest(self) -> str:
        """新メンバー向けのナレッジダイジェストを生成"""
        digest = "# 新メンバー向けナレッジダイジェスト\n\n"
        digest += f"生成日: {datetime.now().strftime('%Y-%m-%d')}\n\n"
 
        for category in self.CATEGORIES:
            entries = self.search("", category=category)
            if not entries:
                continue
 
            category_names = {
                "architecture": "アーキテクチャ",
                "debugging": "デバッグ",
                "workflow": "ワークフロー",
                "domain": "ドメイン知識",
                "tool": "ツール",
                "ai-prompt": "AIプロンプト",
                "postmortem": "障害振り返り",
            }
            digest += f"## {category_names.get(category, category)}\n\n"
 
            for entry in entries[:5]:  # 各カテゴリ最新5件
                digest += f"### {entry.title}\n"
                digest += f"- 著者: {entry.author}\n"
                digest += f"- タグ: {', '.join(entry.tags)}\n"
                digest += f"- 概要: {entry.content[:200]}...\n\n"
 
        return digest

# .ai/onboarding/weekly-checklist.yaml
week_1:
  title: "環境構築とコード理解"
  checkpoints:
    - "開発環境が完全に動作している"
    - "AIツール（Copilot/Claude）を設定済み"
    - "プロジェクトのアーキテクチャを説明できる"
    - "AIを使ってコードベースを探索した"
  mentor_discussion:
    - "AIツールの第一印象は？困っていることは？"
    - "コードベースで最も理解が難しかった部分は？"
 
week_2:
  title: "AI活用実践"
  checkpoints:
    - "AIペアプロで最初のPRを作成した"
    - "チームのプロンプトテンプレートを使った"
    - "AIレビューを受けてフィードバックに対応した"
    - "ナレッジベースに1件以上登録した"
  mentor_discussion:
    - "AIの提案を受け入れた/拒否した判断基準は？"
    - "プロンプトの書き方で工夫した点は？"
 
week_3:
  title: "独立開発への移行"
  checkpoints:
    - "メンターなしで1タスク完了した"
    - "AIツールの自分なりの活用パターンを確立した"
    - "他メンバーのPRをAI支援でレビューした"
  mentor_discussion:
    - "自信を持って取り組めるタスクの範囲は？"
    - "まだ不安な領域は？"
 
week_4:
  title: "自律と貢献"
  checkpoints:
    - "通常のスプリントタスクを独立で完了"
    - "ナレッジベースに3件以上貢献"
    - "オンボーディング改善提案を1つ以上提出"
  mentor_discussion:
    - "オンボーディングプロセス全体の振り返り"
    - "他の新メンバーへのアドバイス"

# オンボーディング効果を定量的に計測するシステム
 
from dataclasses import dataclass, field
from datetime import datetime, date, timedelta
from enum import Enum
 
class CompetencyLevel(Enum):
    BEGINNER = 1      # 環境構築中
    LEARNING = 2      # コード理解中
    PRACTICING = 3    # AI活用実践中
    INDEPENDENT = 4   # 独立開発可能
    CONTRIBUTING = 5  # チームに貢献
 
@dataclass
class OnboardingMetrics:
    """オンボーディング対象者のメトリクス"""
    developer_name: str
    start_date: str
    current_level: CompetencyLevel
    milestones: dict[str, str] = field(default_factory=dict)
 
    # 開発活動メトリクス
    first_commit_date: str = ""
    first_pr_date: str = ""
    first_pr_merged_date: str = ""
    first_solo_task_date: str = ""
    total_prs_merged: int = 0
    total_commits: int = 0
    code_review_given: int = 0
 
    # AI活用メトリクス
    ai_sessions_count: int = 0
    ai_prompt_quality_avg: float = 0.0  # 1-5
    ai_suggestion_acceptance_rate: float = 0.0
    knowledge_base_contributions: int = 0
 
    # メンタリングメトリクス
    mentor_sessions_count: int = 0
    questions_to_mentor: int = 0
    questions_to_ai: int = 0
 
    def days_to_first_pr(self) -> int | None:
        """初PRまでの日数"""
        if not self.first_pr_date:
            return None
        start = datetime.fromisoformat(self.start_date).date()
        first_pr = datetime.fromisoformat(self.first_pr_date).date()
        return (first_pr - start).days
 
    def days_to_independence(self) -> int | None:
        """独立開発までの日数"""
        if not self.first_solo_task_date:
            return None
        start = datetime.fromisoformat(self.start_date).date()
        solo = datetime.fromisoformat(self.first_solo_task_date).date()
        return (solo - start).days
 
    def ai_self_sufficiency_ratio(self) -> float:
        """AI自己解決率（メンターへの質問 vs AIへの質問）"""
        total = self.questions_to_mentor + self.questions_to_ai
        if total == 0:
            return 0.0
        return self.questions_to_ai / total
 
    def generate_progress_report(self) -> str:
        """進捗レポートを生成"""
        days_elapsed = (
            datetime.now().date()
            - datetime.fromisoformat(self.start_date).date()
        ).days
 
        lines = [
            f"# オンボーディング進捗レポート: {self.developer_name}",
            f"",
            f"## 基本情報",
            f"- 入社日: {self.start_date}",
            f"- 経過日数: {days_elapsed}日",
            f"- 現在レベル: {self.current_level.name} ({self.current_level.value}/5)",
            f"",
            f"## マイルストーン達成状況",
        ]
 
        milestone_order = [
            ("環境構築完了", "env_setup"),
            ("初コミット", "first_commit"),
            ("初PR作成", "first_pr"),
            ("初PRマージ", "first_pr_merged"),
            ("初ソロタスク完了", "first_solo"),
            ("AIプロンプト習得", "ai_proficient"),
            ("ナレッジ貢献開始", "knowledge_contrib"),
        ]
        for label, key in milestone_order:
            status = self.milestones.get(key, "未達成")
            icon = "[x]" if status != "未達成" else "[ ]"
            lines.append(f"  - {icon} {label}: {status}")
 
        lines.extend([
            f"",
            f"## 活動メトリクス",
            f"- コミット数: {self.total_commits}",
            f"- マージ済みPR: {self.total_prs_merged}",
            f"- コードレビュー: {self.code_review_given}件",
            f"",
            f"## AI活用メトリクス",
            f"- AIセッション数: {self.ai_sessions_count}",
            f"- プロンプト品質: {self.ai_prompt_quality_avg:.1f}/5.0",
            f"- AI提案採用率: {self.ai_suggestion_acceptance_rate:.0%}",
            f"- AI自己解決率: {self.ai_self_sufficiency_ratio():.0%}",
            f"- ナレッジ貢献: {self.knowledge_base_contributions}件",
        ])
 
        first_pr_days = self.days_to_first_pr()
        if first_pr_days is not None:
            lines.append(f"")
            lines.append(f"## 速度指標")
            lines.append(f"- 初PRまで: {first_pr_days}日")
 
        independence_days = self.days_to_independence()
        if independence_days is not None:
            lines.append(f"- 独立開発まで: {independence_days}日")
 
        return "\n".join(lines)
 
 
@dataclass
class OnboardingBenchmark:
    """オンボーディングのベンチマーク比較"""
 
    historical_data: list[OnboardingMetrics] = field(default_factory=list)
 
    def average_time_to_first_pr(self) -> float:
        """過去の平均初PR日数"""
        days = [m.days_to_first_pr() for m in self.historical_data
                if m.days_to_first_pr() is not None]
        return sum(days) / len(days) if days else 0
 
    def average_time_to_independence(self) -> float:
        """過去の平均独立開発日数"""
        days = [m.days_to_independence() for m in self.historical_data
                if m.days_to_independence() is not None]
        return sum(days) / len(days) if days else 0
 
    def ai_adoption_correlation(self) -> str:
        """AI活用度と立ち上がり速度の相関分析"""
        fast_starters = [
            m for m in self.historical_data
            if m.days_to_independence() is not None
            and m.days_to_independence() < self.average_time_to_independence()
        ]
        slow_starters = [
            m for m in self.historical_data
            if m.days_to_independence() is not None
            and m.days_to_independence() >= self.average_time_to_independence()
        ]
 
        if not fast_starters or not slow_starters:
            return "データ不足"
 
        fast_ai_rate = sum(m.ai_suggestion_acceptance_rate for m in fast_starters) / len(fast_starters)
        slow_ai_rate = sum(m.ai_suggestion_acceptance_rate for m in slow_starters) / len(slow_starters)
 
        return (
            f"立ち上がりが早い人のAI採用率: {fast_ai_rate:.0%}\n"
            f"立ち上がりが遅い人のAI採用率: {slow_ai_rate:.0%}\n"
            f"差分: {abs(fast_ai_rate - slow_ai_rate):.0%}"
        )
 
    def generate_benchmark_report(self) -> str:
        """ベンチマークレポートを生成"""
        return f"""
# オンボーディング ベンチマークレポート
 
## 対象人数: {len(self.historical_data)}名
 
## 速度ベンチマーク
- 平均初PR日数: {self.average_time_to_first_pr():.1f}日
- 平均独立開発日数: {self.average_time_to_independence():.1f}日
 
## AI活用と立ち上がり速度の関係
{self.ai_adoption_correlation()}
 
## 推奨アクション
- 初PRまで5日以上かかる場合 → メンターとの1on1を増やす
- AI採用率が30%未満の場合 → AI研修を再実施
- ナレッジ貢献が0の場合 → ナレッジ登録の習慣化を支援
"""

# .ai/onboarding/comprehensive-checklist.yaml
# AI時代のオンボーディング完全チェックリスト
 
phase_1_environment:
  title: "Phase 1: 環境構築（Day 1-2）"
  items:
    development_setup:
      - "開発マシンのOS確認・初期設定"
      - "Git設定（ユーザー名、メール、SSH鍵）"
      - "プログラミング言語ランタイムのインストール"
      - "エディタ/IDEのインストールと設定"
      - "プロジェクトのcloneとビルド確認"
      - "ローカルでテスト実行を確認"
 
    ai_tools_setup:
      - "GitHub Copilotのインストールと有効化"
      - "Claude Code CLIのインストールと認証"
      - "チーム標準のAI設定ファイルの適用"
      - "AIツールのセキュリティ設定確認（テレメトリ等）"
      - "プロンプトライブラリへのアクセス確認"
 
    access_and_accounts:
      - "GitHub/GitLabのリポジトリアクセス"
      - "CI/CDパイプラインへのアクセス"
      - "Slackの関連チャンネル参加"
      - "プロジェクト管理ツール（Jira/Linear等）のアカウント"
      - "ナレッジベースへのアクセス確認"
 
phase_2_understanding:
  title: "Phase 2: コードベース理解（Day 3-5）"
  items:
    architecture:
      - "AIにアーキテクチャの概要を質問した"
      - "主要コンポーネントの責務を説明できる"
      - "リクエストの流れを追跡できる"
      - "データモデルの関係を理解した"
 
    domain_knowledge:
      - "プロダクトの概要と対象ユーザーを理解した"
      - "主要なビジネスルールを3つ以上説明できる"
      - "ドメイン用語集を確認した"
      - "メンターとドメイン知識のQ&Aセッションを実施した"
 
    development_flow:
      - "ブランチ戦略を理解した"
      - "PR作成からマージまでの手順を理解した"
      - "CI/CDパイプラインの内容を把握した"
      - "デプロイメントプロセスを理解した"
 
phase_3_practice:
  title: "Phase 3: AI活用実践（Week 2）"
  items:
    ai_coding:
      - "AIペアプロで最初のコードを生成した"
      - "AI生成コードのレビュー・修正を行った"
      - "チームのプロンプトテンプレートを3つ以上使用した"
      - "自分なりのプロンプトパターンを1つ開発した"
 
    quality_assurance:
      - "AIを使ってテストを生成した"
      - "AIレビューのフィードバックに対応した"
      - "PR説明文にAI支援の範囲を記載した"
      - "AIの指摘が不適切だったケースを報告した"
 
    first_contributions:
      - "最初のPRを作成した"
      - "PRがマージされた"
      - "他メンバーのPRにレビューコメントした"
      - "ナレッジベースに最初のエントリを登録した"
 
phase_4_independence:
  title: "Phase 4: 自律（Week 3-4）"
  items:
    independent_work:
      - "メンターの常時支援なしでタスクを完了した"
      - "AI活用の自分なりのワークフローを確立した"
      - "AIの回答が不正確な場合に自力で修正できた"
      - "技術的な意思決定を自律的に行った"
 
    team_contribution:
      - "ナレッジベースに3件以上貢献した"
      - "チームのプロンプトテンプレートに改善提案した"
      - "オンボーディングプロセスの改善提案を提出した"
      - "新しい知見をチームに共有した"
 
    assessment:
      - "メンターによる最終評価を受けた"
      - "自己評価レポートを作成した"
      - "今後の成長目標を設定した"

# オンボーディング卒業判定システム
 
from dataclasses import dataclass
 
@dataclass
class GraduationCriteria:
    """オンボーディング卒業判定基準"""
 
    # 必須基準（全て満たす必要がある）
    MANDATORY = {
        "first_pr_merged": "PRが1件以上マージされている",
        "ai_tool_setup": "AIツールが正しく設定されている",
        "code_understanding": "メンターが理解度を承認",
        "security_rules": "セキュリティルールを理解",
    }
 
    # 推奨基準（80%以上満たすことが望ましい）
    RECOMMENDED = {
        "solo_task_completed": "ソロタスクを1件以上完了",
        "knowledge_contribution": "ナレッジベースに1件以上貢献",
        "code_review_given": "他メンバーのPRをレビュー",
        "ai_prompt_quality": "プロンプト品質スコア3.0以上",
        "ai_acceptance_rate": "AI提案採用率40%以上",
    }
 
    def evaluate(self, metrics: OnboardingMetrics) -> dict:
        """卒業判定を実行"""
        mandatory_results = {}
        mandatory_results["first_pr_merged"] = metrics.total_prs_merged >= 1
        mandatory_results["ai_tool_setup"] = metrics.ai_sessions_count > 0
        mandatory_results["code_understanding"] = metrics.current_level.value >= 3
        mandatory_results["security_rules"] = "security" in metrics.milestones
 
        recommended_results = {}
        recommended_results["solo_task_completed"] = metrics.first_solo_task_date != ""
        recommended_results["knowledge_contribution"] = metrics.knowledge_base_contributions >= 1
        recommended_results["code_review_given"] = metrics.code_review_given >= 1
        recommended_results["ai_prompt_quality"] = metrics.ai_prompt_quality_avg >= 3.0
        recommended_results["ai_acceptance_rate"] = metrics.ai_suggestion_acceptance_rate >= 0.4
 
        mandatory_pass = all(mandatory_results.values())
        recommended_pass_rate = sum(recommended_results.values()) / len(recommended_results)
 
        return {
            "graduated": mandatory_pass and recommended_pass_rate >= 0.8,
            "mandatory": mandatory_results,
            "mandatory_all_pass": mandatory_pass,
            "recommended": recommended_results,
            "recommended_pass_rate": recommended_pass_rate,
            "message": self._generate_message(mandatory_pass, recommended_pass_rate),
        }
 
    def _generate_message(self, mandatory_pass: bool, recommended_rate: float) -> str:
        if mandatory_pass and recommended_rate >= 0.8:
            return "卒業判定: 合格。通常のスプリントに参加可能です。"
        elif mandatory_pass and recommended_rate >= 0.6:
            return "卒業判定: 条件付き合格。一部の推奨基準を引き続き達成してください。"
        elif mandatory_pass:
            return "卒業判定: 保留。推奨基準の達成率が低いため、追加1週間のサポートを推奨します。"
        else:
            return "卒業判定: 未達。必須基準が未達成のため、メンターと追加計画を策定してください。"

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# デバッグ用ユーティリティ
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]

# チーム間の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)