# エージェント型ツールの動作イメージ
# Claude Code を例にした自律タスク実行フロー
 
# ステップ1: ユーザーが高レベルの指示を与える
# claude "Issue #42のバグを修正してPRを作成して"
 
# ステップ2: エージェントが自律的に以下を実行
#   1. GitHub Issue #42の内容を読み取り
#   2. 関連するソースコードを特定（Grep/Glob）
#   3. バグの原因を分析
#   4. 修正コードを生成・適用
#   5. テストを実行して確認
#   6. 失敗した場合は自動で修正を繰り返す
#   7. 全テスト通過後、ブランチを作成
#   8. コミットしてPRを作成
 
# ステップ3: 人間がPRをレビュー・承認

# インフラ層の構成要素と選択肢
 
INFRASTRUCTURE_OPTIONS = {
    "GPU_PROVIDERS": {
        "AWS": {
            "service": "Amazon Bedrock / SageMaker",
            "gpu_types": ["A100", "H100", "Trainium"],
            "advantages": "既存AWS環境との統合が容易",
            "pricing": "オンデマンド/リザーブドインスタンス",
        },
        "Azure": {
            "service": "Azure OpenAI Service",
            "gpu_types": ["A100", "H100"],
            "advantages": "GPT系モデルの最適化",
            "pricing": "トークン課金",
        },
        "Google Cloud": {
            "service": "Vertex AI",
            "gpu_types": ["TPU v5", "A100", "H100"],
            "advantages": "Geminiモデルとの統合",
            "pricing": "従量課金",
        },
    },
    "API_GATEWAYS": [
        "Anthropic API (直接)",
        "OpenAI API (直接)",
        "AWS API Gateway + Bedrock",
        "LiteLLM (統合プロキシ)",
    ],
    "SELF_HOSTING": {
        "Ollama": "ローカルLLM実行環境（個人開発向け）",
        "vLLM": "高スループットのLLM推論サーバー",
        "TGI": "Hugging Face推論サーバー",
    },
}

# 主要LLMモデルのコード能力比較（2026年時点）
 
MODEL_COMPARISON = {
    "Claude Opus 4": {
        "provider": "Anthropic",
        "context_window": "200K tokens",
        "code_quality": "★★★★★",
        "reasoning": "★★★★★",
        "speed": "★★★☆☆",
        "best_for": "複雑な設計判断、マルチファイル理解",
    },
    "Claude Sonnet 4": {
        "provider": "Anthropic",
        "context_window": "200K tokens",
        "code_quality": "★★★★☆",
        "reasoning": "★★★★☆",
        "speed": "★★★★★",
        "best_for": "日常的なコーディング、バランス型",
    },
    "GPT-4o": {
        "provider": "OpenAI",
        "context_window": "128K tokens",
        "code_quality": "★★★★☆",
        "reasoning": "★★★★☆",
        "speed": "★★★★☆",
        "best_for": "マルチモーダル入力、汎用タスク",
    },
    "Gemini 2.0": {
        "provider": "Google",
        "context_window": "1M+ tokens",
        "code_quality": "★★★★☆",
        "reasoning": "★★★★☆",
        "speed": "★★★★☆",
        "best_for": "超長コンテキスト、大規模コードベース",
    },
    "Llama 3.1 405B": {
        "provider": "Meta (OSS)",
        "context_window": "128K tokens",
        "code_quality": "★★★☆☆",
        "reasoning": "★★★☆☆",
        "speed": "★★★★☆ (自ホスト依存)",
        "best_for": "セキュリティ要件の厳しい環境",
    },
    "Codestral": {
        "provider": "Mistral (OSS)",
        "context_window": "32K tokens",
        "code_quality": "★★★★☆",
        "reasoning": "★★★☆☆",
        "speed": "★★★★★",
        "best_for": "コード補完特化、ローカル実行",
    },
}

# MCPの概念と動作原理
 
# MCP (Model Context Protocol) はAnthropicが策定したオープンプロトコル
# LLMアプリケーションと外部ツール・データソースを標準化された方法で接続する
 
# 従来のツール連携:
#   各ツールごとにカスタムAPIクライアントを実装
#   → 統合コストが高い、互換性がない
 
# MCPによるツール連携:
#   標準プロトコルに準拠したサーバーを接続するだけ
#   → プラグアンドプレイ、互換性が保証される
 
MCP_ARCHITECTURE = """

"""

# GitHub Copilot: エディタ内で自動補完
# (VSCodeでTabキーで候補を受け入れ)
 
# Claude Code: CLIからプロジェクト全体を操作
claude "このプロジェクトのテストカバレッジを80%に上げて"
 
# Cursor: AIチャットでコード生成
# Cmd+K でインラインコード生成
# Cmd+L でチャットパネル

# AI補完の効果を示す例: 従来の手動コーディング
def calculate_tax(income: float, deductions: list[float]) -> float:
    """所得税を計算する"""
    taxable_income = income - sum(deductions)
    if taxable_income <= 1_950_000:
        return taxable_income * 0.05
    elif taxable_income <= 3_300_000:
        return taxable_income * 0.10 - 97_500
    elif taxable_income <= 6_950_000:
        return taxable_income * 0.20 - 427_500
    elif taxable_income <= 9_000_000:
        return taxable_income * 0.23 - 636_000
    elif taxable_income <= 18_000_000:
        return taxable_income * 0.33 - 1_536_000
    elif taxable_income <= 40_000_000:
        return taxable_income * 0.40 - 2_796_000
    else:
        return taxable_income * 0.45 - 4_796_000
 
# AIなら「日本の所得税計算関数を作って」だけで上記が生成される

// AI支援によるAPI実装の例
// プロンプト: "Express.jsでCRUD APIを作成。バリデーション付き"
 
import express from 'express';
import { z } from 'zod';
 
const UserSchema = z.object({
  name: z.string().min(1).max(100),
  email: z.string().email(),
  age: z.number().int().min(0).max(150).optional(),
});
 
const app = express();
app.use(express.json());
 
// AIが生成した完全なCRUDエンドポイント
app.post('/users', async (req, res) => {
  const result = UserSchema.safeParse(req.body);
  if (!result.success) {
    return res.status(400).json({ errors: result.error.issues });
  }
  // ... DB操作
});

# AIツール連携の例: MCPプロトコル
# Claude CodeがGitHubのIssueを読み、PRを作成する流れ
 
# 1. Issueの内容を取得 (MCP: GitHub Tool)
# 2. コードベースを分析 (MCP: File System Tool)
# 3. 修正コードを生成 (LLM推論)
# 4. テストを実行 (MCP: Bash Tool)
# 5. PRを作成 (MCP: GitHub Tool)
 
# これが1つのプロンプトで実行される:
# claude "Issue #42を修正してPRを作成して"

# AI開発ツールの設定例: .cursorrules
# プロジェクト固有のAI指示を定義
rules:
  - "TypeScriptを使用し、strict modeを有効にする"
  - "テストはVitestで書く"
  - "コンポーネントはfunction宣言で書く"
  - "エラーハンドリングにはResult型を使う"
  - "コメントは日本語で書く"

# AI開発ツール導入のROI計算シミュレーション
 
class AIToolROICalculator:
    """AI開発ツールの投資対効果を計算する"""
 
    def calculate_roi(
        self,
        team_size: int,
        avg_salary_monthly: int,  # 1人あたり月額給与（円）
        tool_cost_per_person: int,  # ツール月額コスト/人（円）
        productivity_gain_percent: float,  # 生産性向上率（0.0-1.0）
    ) -> dict:
        """ROIを計算する"""
 
        # 月間コスト
        total_tool_cost = team_size * tool_cost_per_person
 
        # 月間効果（生産性向上分を人件費換算）
        total_salary = team_size * avg_salary_monthly
        productivity_value = total_salary * productivity_gain_percent
 
        # ROI
        monthly_net_benefit = productivity_value - total_tool_cost
        roi_percent = (monthly_net_benefit / total_tool_cost) * 100
 
        return {
            "monthly_tool_cost": total_tool_cost,
            "monthly_productivity_value": productivity_value,
            "monthly_net_benefit": monthly_net_benefit,
            "roi_percent": roi_percent,
            "payback_period_months": 1 if monthly_net_benefit > 0 else "N/A",
        }
 
 
# 計算例
calc = AIToolROICalculator()
result = calc.calculate_roi(
    team_size=10,
    avg_salary_monthly=800_000,      # 月額80万円
    tool_cost_per_person=5_000,       # Copilot $39 ≈ 5,000円/月
    productivity_gain_percent=0.30,   # 30%の生産性向上
)
 
# 結果:
# - ツールコスト: 50,000円/月
# - 生産性向上分: 2,400,000円/月
# - 純利益: 2,350,000円/月
# - ROI: 4,700%
# → 圧倒的にプラスのROI

# BAD: AIの出力をそのまま使用
# プロンプト: "ユーザー認証を実装して"
def authenticate(username, password):
    # AIが生成したが、セキュリティ的に危険なコード
    query = f"SELECT * FROM users WHERE name='{username}' AND pass='{password}'"
    # ↑ SQLインジェクション脆弱性！
    result = db.execute(query)
    return result is not None
 
# GOOD: AIの出力を理解・検証してから使用
def authenticate(username: str, password: str) -> bool:
    """パラメータ化クエリとハッシュ比較で安全に認証"""
    query = "SELECT password_hash FROM users WHERE username = ?"
    result = db.execute(query, (username,))
    if result is None:
        return False
    return bcrypt.checkpw(password.encode(), result['password_hash'])

# BAD: 機密情報をAIツールに送信してしまう
 
# プロジェクト内の .env ファイルの内容をAIに貼り付け
# → API キー、データベースパスワードが外部サーバーに送信される
 
# GOOD: 機密情報の取り扱いを明確にルール化
 
# .copilotignore / .cursorignore で除外
SENSITIVE_FILES = [
    ".env",
    ".env.local",
    ".env.production",
    "*.pem",
    "*.key",
    "credentials/",
    "secrets/",
    "config/production.yaml",
]
 
# AIツール利用ポリシーの例
AI_USAGE_POLICY = {
    "allowed": [
        "パブリックAPIの使い方の質問",
        "アルゴリズムの実装相談",
        "テストコードの生成依頼",
        "ドキュメントの下書き",
    ],
    "requires_review": [
        "認証・認可ロジックの生成",
        "データベーススキーマの設計",
        "セキュリティ関連のコード",
    ],
    "prohibited": [
        "機密設定ファイルの送信",
        "顧客データを含むログの貼り付け",
        "社内専用APIのエンドポイント情報",
        "暗号鍵・秘密鍵の送信",
    ],
}

## AI開発ツール選定チェックリスト
 
### セキュリティ（必須）
- [ ] コードの送信先とデータ保持ポリシーを確認
- [ ] SOC 2 / ISO 27001等の認証状況を確認
- [ ] VPC内での利用可否を確認（エンタープライズ向け）
- [ ] .copilotignore等のファイル除外機能の有無
- [ ] IP補償（知的財産保護）の有無
 
### 機能要件
- [ ] チームで使用している言語・フレームワークへの対応
- [ ] エディタ・IDE との統合性
- [ ] コンテキスト理解の範囲（ファイル/プロジェクト全体）
- [ ] Agent Mode の有無と品質
- [ ] マルチファイル編集の対応
 
### 運用要件
- [ ] チーム管理機能（管理者向けダッシュボード）
- [ ] 利用量の監視・制限機能
- [ ] SSO / SAML 認証への対応
- [ ] API キーの管理方法
- [ ] SLA（サービスレベル保証）
 
### コスト
- [ ] 人数 × 単価の月額コスト
- [ ] API従量課金の見積もり
- [ ] トライアル期間の有無
- [ ] 年間契約での割引

# 2026年のAI開発エコシステムのキートレンド
 
TRENDS_2026 = {
    "エージェント型開発の本格化": {
        "概要": "単なるコード補完から、タスク全体を自律的に遂行するエージェントへ",
        "具体例": [
            "Issue→修正→テスト→PR作成が1コマンドで完了",
            "CI/CDパイプラインの自動修復",
            "マルチファイルのリファクタリング自動実行",
        ],
        "影響": "開発者の役割がコーダーからオーケストレーターへシフト",
    },
    "MCPエコシステムの拡大": {
        "概要": "MCPサーバーが標準化され、ツール連携が容易に",
        "具体例": [
            "公式MCPサーバーの増加（GitHub, Slack, Jira, 各種DB等）",
            "カスタムMCPサーバーの社内構築",
            "MCPマーケットプレイスの登場",
        ],
        "影響": "AIツールが社内システムと深く統合される",
    },
    "マルチモーダル開発": {
        "概要": "テキスト以外の入力（図、スクリーンショット、音声）から直接コード生成",
        "具体例": [
            "UIモックアップ画像からReactコンポーネントを生成",
            "ホワイトボードの設計図からアーキテクチャコードを生成",
            "音声指示による対話的プログラミング",
        ],
        "影響": "デザイナーとエンジニアの境界が曖昧になる",
    },
    "ローカルLLMの品質向上": {
        "概要": "オープンソースモデルの性能が商用レベルに近づく",
        "具体例": [
            "Llama系モデルのコード補完性能向上",
            "Codestralの32Bモデルが商用品質に",
            "Apple Silicon/NPU最適化されたローカルモデル",
        ],
        "影響": "セキュリティ要件の厳しい環境でもAI開発が可能に",
    },
}

# 演習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()

# 設計判断の記録テンプレート
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 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
            }
        }

# テストの ROI（投資対効果）を示す例
class TestROICalculator:
    """テスト投資対効果の計算"""
 
    def __init__(self):
        self.test_writing_hours = 0
        self.bugs_prevented = 0
        self.debug_hours_saved = 0
 
    def add_test_investment(self, hours: float):
        """テスト作成にかかった時間"""
        self.test_writing_hours += hours
 
    def add_bug_prevention(self, count: int, avg_debug_hours: float = 2.0):
        """テストにより防いだバグ"""
        self.bugs_prevented += count
        self.debug_hours_saved += count * avg_debug_hours
 
    def calculate_roi(self) -> dict:
        """ROIの計算"""
        net_benefit = self.debug_hours_saved - self.test_writing_hours
        roi_percent = (net_benefit / self.test_writing_hours * 100
                      if self.test_writing_hours > 0 else 0)
        return {
            'test_hours': self.test_writing_hours,
            'bugs_prevented': self.bugs_prevented,
            'hours_saved': self.debug_hours_saved,
            'net_benefit_hours': net_benefit,
            'roi_percent': f'{roi_percent:.1f}%'
        }