# .ai/prompts/code-review.yaml
# チーム共有プロンプトテンプレート
name: コードレビュー依頼
description: PRのコードレビューをAIに依頼する標準テンプレート
template: |
  以下のPull Requestをレビューしてください。
 
  ## コンテキスト
  - プロジェクト: {{project_name}}
  - 機能概要: {{feature_description}}
  - 対象ファイル: {{changed_files}}
 
  ## レビュー観点
  1. ロジックの正当性
  2. エッジケースの考慮
  3. パフォーマンスへの影響
  4. セキュリティリスク
  5. コーディング規約の遵守
  6. テストの十分性
 
  ## コーディング規約
  - {{coding_standards_url}}
 
  ## 変更差分
  ```diff
  {{diff_content}}

# .github/workflows/ai-review.yml
name: AI Code Review
 
on:
  pull_request:
    types: [opened, synchronize]
 
jobs:
  ai-review:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      contents: read
 
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - name: Get diff
        id: diff
        run: |
          git diff origin/${{ github.base_ref }}...HEAD > /tmp/diff.txt
 
      - name: AI Review
        uses: actions/github-script@v7
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        with:
          script: |
            const fs = require('fs');
            const diff = fs.readFileSync('/tmp/diff.txt', 'utf8');
 
            // AIレビュー実行（Anthropic API呼び出し）
            const response = await fetch('https://api.anthropic.com/v1/messages', {
              method: 'POST',
              headers: {
                'Content-Type': 'application/json',
                'x-api-key': process.env.ANTHROPIC_API_KEY,
                'anthropic-version': '2023-06-01',
              },
              body: JSON.stringify({
                model: 'claude-sonnet-4-20250514',
                max_tokens: 4096,
                messages: [{
                  role: 'user',
                  content: `以下のdiffをレビューしてください。
                    重要度(Critical/Major/Minor)付きで指摘し、
                    修正案を提示してください。\n\n${diff}`
                }],
              }),
            });
 
            const result = await response.json();
            const review = result.content[0].text;
 
            // PRにコメント投稿
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: `## 🤖 AI Code Review\n\n${review}`,
            });

# チームAIスキル評価・可視化ツール
from dataclasses import dataclass
 
@dataclass
class AISkillAssessment:
    """開発者のAIスキル評価"""
    developer: str
    prompt_engineering: int    # 1-5: プロンプト設計力
    tool_proficiency: int      # 1-5: AIツール操作力
    output_evaluation: int     # 1-5: AI出力の評価力
    workflow_integration: int  # 1-5: ワークフロー統合力
    teaching_ability: int      # 1-5: 他者への指導力
 
    @property
    def total_score(self) -> int:
        return (
            self.prompt_engineering
            + self.tool_proficiency
            + self.output_evaluation
            + self.workflow_integration
            + self.teaching_ability
        )
 
    @property
    def level(self) -> str:
        s = self.total_score
        if s >= 22:
            return "AI Champion"
        elif s >= 17:
            return "AI Practitioner"
        elif s >= 12:
            return "AI Learner"
        else:
            return "AI Beginner"
 
def generate_skill_matrix(team: list[AISkillAssessment]) -> str:
    """チームスキルマトリクスをテキスト表示"""
    header = (
        f"{'名前':12s} {'Prompt':8s} {'Tool':8s} "
        f"{'Eval':8s} {'Flow':8s} {'Teach':8s} {'Level':16s}"
    )
    lines = [header, "-" * len(header)]
 
    for member in sorted(team, key=lambda m: m.total_score, reverse=True):
        lines.append(
            f"{member.developer:12s} "
            f"{'*' * member.prompt_engineering:8s} "
            f"{'*' * member.tool_proficiency:8s} "
            f"{'*' * member.output_evaluation:8s} "
            f"{'*' * member.workflow_integration:8s} "
            f"{'*' * member.teaching_ability:8s} "
            f"{member.level:16s}"
        )
 
    return "\n".join(lines)

# AIを活用したチーム知識管理システム
 
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
from pathlib import Path
import json
 
class KnowledgeType(Enum):
    DECISION = "decision"           # 設計判断・意思決定
    PATTERN = "pattern"             # コードパターン・慣習
    TROUBLESHOOT = "troubleshoot"   # トラブルシューティング
    DOMAIN = "domain"              # ドメイン知識
    PROCESS = "process"            # プロセス・手順
    TOOLING = "tooling"            # ツール使用法
 
@dataclass
class KnowledgeEntry:
    """知識ベースのエントリ"""
    id: str
    title: str
    knowledge_type: KnowledgeType
    content: str
    context: str                    # どのような状況で使うか
    created_by: str
    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
    tags: list[str] = field(default_factory=list)
    related_files: list[str] = field(default_factory=list)
    ai_generated: bool = False      # AIが生成した知識か
    verified_by: str = ""           # 人間の検証者
    usage_count: int = 0            # 参照回数
 
@dataclass
class TeamKnowledgeBase:
    """チーム知識ベース管理"""
    team_name: str
    entries: list[KnowledgeEntry] = field(default_factory=list)
    kb_dir: Path = field(default_factory=lambda: Path(".ai/knowledge"))
 
    def add_from_code_review(
        self,
        pr_number: int,
        reviewer: str,
        learning: str,
        related_code: str,
    ) -> KnowledgeEntry:
        """コードレビューから知識を抽出して登録"""
        entry = KnowledgeEntry(
            id=f"review-{pr_number}-{len(self.entries)}",
            title=f"PR #{pr_number} からの学び",
            knowledge_type=KnowledgeType.PATTERN,
            content=learning,
            context=f"PR #{pr_number} のレビュー中に発見",
            created_by=reviewer,
            related_files=[related_code],
            tags=["code-review", f"pr-{pr_number}"],
        )
        self.entries.append(entry)
        return entry
 
    def add_from_incident(
        self,
        incident_id: str,
        responder: str,
        root_cause: str,
        fix_description: str,
        prevention: str,
    ) -> KnowledgeEntry:
        """インシデント対応から知識を抽出"""
        content = f"""
## 根本原因
{root_cause}
 
## 修正内容
{fix_description}
 
## 再発防止策
{prevention}
"""
        entry = KnowledgeEntry(
            id=f"incident-{incident_id}",
            title=f"インシデント {incident_id} の教訓",
            knowledge_type=KnowledgeType.TROUBLESHOOT,
            content=content,
            context=f"インシデント {incident_id} の事後分析",
            created_by=responder,
            tags=["incident", "postmortem"],
        )
        self.entries.append(entry)
        return entry
 
    def ai_generate_summary(self) -> str:
        """AIに知識ベースの要約を生成させるためのプロンプト"""
        entries_text = "\n".join(
            f"- [{e.knowledge_type.value}] {e.title}: {e.content[:100]}..."
            for e in self.entries[-20:]  # 直近20件
        )
 
        return f"""
以下のチーム知識ベースの直近エントリを分析し、
チームの技術的傾向と改善提案を生成してください。
 
チーム: {self.team_name}
エントリ数: {len(self.entries)}
 
直近のエントリ:
{entries_text}
 
分析してほしい観点:
1. 繰り返し発生している問題パターン
2. チームの技術的強み・弱み
3. 知識が不足している領域
4. 推奨するアクション（研修、ツール導入等）
"""
 
    def search(self, query: str, top_k: int = 5) -> list[KnowledgeEntry]:
        """知識ベースをキーワード検索"""
        scored = []
        query_lower = query.lower()
        for entry in self.entries:
            score = 0
            if query_lower in entry.title.lower():
                score += 10
            if query_lower in entry.content.lower():
                score += 5
            for tag in entry.tags:
                if query_lower in tag.lower():
                    score += 3
            if score > 0:
                scored.append((score, entry))
 
        scored.sort(key=lambda x: x[0], reverse=True)
        return [entry for _, entry in scored[:top_k]]
 
    def save(self) -> None:
        """知識ベースをファイルに保存"""
        self.kb_dir.mkdir(parents=True, exist_ok=True)
        for entry in self.entries:
            path = self.kb_dir / f"{entry.id}.json"
            with open(path, "w", encoding="utf-8") as f:
                json.dump({
                    "id": entry.id,
                    "title": entry.title,
                    "type": entry.knowledge_type.value,
                    "content": entry.content,
                    "context": entry.context,
                    "created_by": entry.created_by,
                    "created_at": entry.created_at,
                    "tags": entry.tags,
                    "related_files": entry.related_files,
                    "ai_generated": entry.ai_generated,
                    "verified_by": entry.verified_by,
                    "usage_count": entry.usage_count,
                }, f, indent=2, ensure_ascii=False)

# AIを活用したADR（アーキテクチャ決定記録）管理
 
from dataclasses import dataclass, field
from datetime import date
 
@dataclass
class ADREntry:
    """アーキテクチャ決定記録"""
    number: int
    title: str
    status: str  # "proposed", "accepted", "deprecated", "superseded"
    date: str
    context: str
    decision: str
    consequences: str
    alternatives_considered: list[str] = field(default_factory=list)
    ai_analysis: str = ""  # AIによるトレードオフ分析
 
class ADRManager:
    """ADR管理ツール"""
 
    def __init__(self, adr_dir: str = "docs/adr"):
        self.adr_dir = Path(adr_dir)
        self.adr_dir.mkdir(parents=True, exist_ok=True)
 
    def create_adr_prompt(
        self,
        title: str,
        context: str,
        options: list[str],
    ) -> str:
        """ADR作成のためのAIプロンプトを生成"""
        options_text = "\n".join(f"  {i+1}. {opt}" for i, opt in enumerate(options))
 
        return f"""
以下のアーキテクチャ決定について、ADRを作成してください。
 
## タイトル
{title}
 
## コンテキスト
{context}
 
## 検討中の選択肢
{options_text}
 
以下の形式で出力してください:
 
### 各選択肢のトレードオフ分析
（メリット、デメリット、リスクを具体的に）
 
### 推奨される決定
（理由と共に）
 
### 予測される影響
（短期的・長期的な影響）
 
### 将来の見直しトリガー
（この決定を見直すべき条件）
"""
 
    def generate_adr_markdown(self, entry: ADREntry) -> str:
        """ADRをMarkdown形式で生成"""
        alternatives = "\n".join(
            f"- {alt}" for alt in entry.alternatives_considered
        )
 
        return f"""# ADR-{entry.number:04d}: {entry.title}
 
## ステータス
{entry.status}
 
## 日付
{entry.date}
 
## コンテキスト
{entry.context}
 
## 検討した代替案
{alternatives}
 
## 決定
{entry.decision}
 
## AIによるトレードオフ分析
{entry.ai_analysis}
 
## 結果
{entry.consequences}
"""
 
    def save_adr(self, entry: ADREntry) -> Path:
        """ADRをファイルとして保存"""
        filename = f"{entry.number:04d}-{entry.title.replace(' ', '-').lower()}.md"
        path = self.adr_dir / filename
        content = self.generate_adr_markdown(entry)
        path.write_text(content, encoding="utf-8")
        return path

# .ai/communication/templates.yaml
# チームコミュニケーション用AIテンプレート
 
templates:
  # PRの説明文を自動生成
  pr_description:
    name: "PR説明文自動生成"
    trigger: "PR作成時に自動実行"
    prompt: |
      以下のgit diffから、PR説明文を生成してください。
 
      ## 形式
      ### 変更概要
      （1-2文で変更の目的を説明）
 
      ### 変更内容
      （箇条書きで具体的な変更を列挙）
 
      ### テスト方法
      （動作確認の手順）
 
      ### 影響範囲
      （この変更が影響するコンポーネント・機能）
 
      ### レビュー観点
      （レビュアーに特に見てほしいポイント）
 
      ## diff
      {{diff}}
 
  # デイリースタンドアップのサマリー生成
  standup_summary:
    name: "スタンドアップサマリー"
    trigger: "毎朝9:00に自動実行"
    prompt: |
      以下のチームメンバーのGitHub活動データから、
      デイリースタンドアップ用のサマリーを生成してください。
 
      ## データソース
      - 昨日のコミット: {{commits}}
      - オープンPR: {{open_prs}}
      - マージされたPR: {{merged_prs}}
      - 新規Issue: {{new_issues}}
 
      ## 出力形式
      各メンバーについて:
      - 昨日やったこと
      - 今日の予定（推測）
      - ブロッカー（あれば）
 
  # Slackでの技術質問への自動回答
  tech_support:
    name: "技術質問自動回答"
    trigger: "#dev-support チャンネルへの投稿"
    prompt: |
      以下の技術質問に対して、チームの知識ベースと
      プロジェクトのドキュメントを参照して回答してください。
 
      質問: {{question}}
 
      参考ドキュメント: {{relevant_docs}}
      過去の類似質問: {{similar_questions}}
 
      回答後に「この回答は正確ですか？」と確認を求めてください。

# AI支援による会議の効率化ツール
 
from dataclasses import dataclass, field
from datetime import datetime
 
@dataclass
class MeetingAgenda:
    """AIが生成する会議アジェンダ"""
    title: str
    date: str
    duration_minutes: int
    participants: list[str]
    topics: list[dict] = field(default_factory=list)
 
@dataclass
class MeetingFacilitator:
    """AI会議ファシリテーター"""
 
    def generate_sprint_review_agenda(
        self,
        sprint_number: int,
        completed_stories: list[str],
        incomplete_stories: list[str],
        metrics: dict,
    ) -> str:
        """スプリントレビューのアジェンダを自動生成"""
        completed_list = "\n".join(f"  - {s}" for s in completed_stories)
        incomplete_list = "\n".join(f"  - {s}" for s in incomplete_stories)
 
        return f"""
# Sprint {sprint_number} レビュー アジェンダ
 
## 1. スプリント概要（5分）
- 期間: {metrics.get('start_date', 'N/A')} 〜 {metrics.get('end_date', 'N/A')}
- 計画ポイント: {metrics.get('planned_points', 0)}
- 完了ポイント: {metrics.get('completed_points', 0)}
- 達成率: {metrics.get('completion_rate', 0):.0%}
 
## 2. 完了ストーリーのデモ（20分）
{completed_list}
 
## 3. 未完了ストーリーの状況報告（10分）
{incomplete_list}
 
## 4. AI活用メトリクス（5分）
- AIペアプロセッション数: {metrics.get('ai_sessions', 0)}
- AI生成コード比率: {metrics.get('ai_code_ratio', 0):.0%}
- AIレビュー指摘の採用率: {metrics.get('ai_review_acceptance', 0):.0%}
 
## 5. 振り返り・改善提案（10分）
- チームからのフィードバック
- AI活用の改善ポイント
 
## 6. 次スプリントの優先事項（10分）
"""
 
    def generate_retro_prompts(self, sprint_metrics: dict) -> str:
        """レトロスペクティブのAI支援プロンプト"""
        return f"""
チームのスプリントメトリクスに基づいて、
レトロスペクティブの議論のたたき台を生成してください。
 
メトリクス:
- ベロシティ: {sprint_metrics.get('velocity', 'N/A')}
- テストカバレッジ: {sprint_metrics.get('coverage', 'N/A')}%
- バグ発生率: {sprint_metrics.get('bug_rate', 'N/A')}件/スプリント
- PRマージ平均時間: {sprint_metrics.get('pr_merge_time', 'N/A')}時間
- AI活用度: {sprint_metrics.get('ai_usage', 'N/A')}%
 
以下の形式で出力してください:
 
### うまくいったこと（Keep）
- メトリクスから読み取れるポジティブな傾向を3つ
 
### 改善すべきこと（Problem）
- メトリクスから読み取れる課題を3つ
 
### 試したいこと（Try）
- 具体的な改善アクションを3つ（AI活用の観点含む）
"""

# .ai/governance/ai-usage-policy.yaml
# チームAI利用ポリシー
 
policy:
  version: "2.0"
  last_updated: "2026-02-01"
  approved_by: "Engineering Manager"
 
  # データセキュリティ
  data_security:
    allowed_data_types:
      - "オープンソースコード"
      - "社内技術ドキュメント（機密以外）"
      - "テストデータ（匿名化済み）"
    prohibited_data_types:
      - "顧客の個人情報（PII）"
      - "認証情報（APIキー、パスワード、トークン）"
      - "財務データ（未公開）"
      - "医療データ"
      - "契約書・法務文書"
    encryption_requirement: "転送中のデータはTLS 1.3以上"
 
  # AIツール使用ルール
  tool_usage:
    approved_tools:
      - name: "Claude Code"
        allowed_for: ["コード生成", "レビュー", "テスト", "ドキュメント"]
        restrictions: "機密コードには使用禁止"
      - name: "GitHub Copilot"
        allowed_for: ["コード補完", "テスト生成"]
        restrictions: "Telemetry無効化必須"
    approval_required_for:
      - "新しいAIツールの導入"
      - "AIツールの本番環境への統合"
      - "カスタムAIモデルのデプロイ"
 
  # コード品質ルール
  code_quality:
    ai_generated_code_rules:
      - "全てのAI生成コードは人間のレビューを通すこと"
      - "セキュリティクリティカルなコードはシニアエンジニア以上がレビュー"
      - "AI生成コードにはテストの追加が必須"
      - "PRの説明にAI支援の範囲を記載"
    minimum_test_coverage: 80
    mandatory_security_scan: true
 
  # 監査・記録
  audit:
    log_ai_usage: true
    retention_period_days: 365
    quarterly_review: true
    metrics_tracking:
      - "AI生成コード比率"
      - "AI生成コードの欠陥密度"
      - "AIレビュー指摘の精度"

# AIガバナンスポリシーの自動チェックツール
 
import re
from dataclasses import dataclass, field
from pathlib import Path
 
@dataclass
class ComplianceIssue:
    """コンプライアンス違反"""
    severity: str  # "critical", "warning", "info"
    category: str
    message: str
    file: str = ""
    line: int = 0
 
class AIGovernanceChecker:
    """AIガバナンスポリシーのコンプライアンスチェック"""
 
    # チェック対象パターン
    SENSITIVE_PATTERNS = {
        "pii_email": {
            "pattern": r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
            "message": "メールアドレスが検出されました",
            "severity": "critical",
            "exclude_files": ["*.test.*", "*.spec.*"],
        },
        "api_key": {
            "pattern": r'(?:api[_-]?key|apikey)\s*[=:]\s*["\'][a-zA-Z0-9]{20,}',
            "message": "APIキーのハードコードが検出されました",
            "severity": "critical",
        },
        "password": {
            "pattern": r'(?:password|passwd|pwd)\s*[=:]\s*["\'][^"\']{4,}',
            "message": "パスワードのハードコードが検出されました",
            "severity": "critical",
        },
        "private_key": {
            "pattern": r'-----BEGIN (?:RSA |EC )?PRIVATE KEY-----',
            "message": "秘密鍵が検出されました",
            "severity": "critical",
        },
        "ip_address": {
            "pattern": r'\b(?:10|172\.(?:1[6-9]|2\d|3[01])|192\.168)\.\d{1,3}\.\d{1,3}\b',
            "message": "内部IPアドレスが検出されました",
            "severity": "warning",
        },
    }
 
    def __init__(self):
        self.issues: list[ComplianceIssue] = []
 
    def check_file(self, file_path: Path) -> list[ComplianceIssue]:
        """ファイルのコンプライアンスチェック"""
        issues = []
        try:
            content = file_path.read_text(encoding="utf-8")
        except (UnicodeDecodeError, PermissionError):
            return issues
 
        for name, check in self.SENSITIVE_PATTERNS.items():
            # 除外ファイルの確認
            excludes = check.get("exclude_files", [])
            if any(file_path.match(exc) for exc in excludes):
                continue
 
            for match in re.finditer(check["pattern"], content, re.IGNORECASE):
                line_num = content[:match.start()].count("\n") + 1
                issue = ComplianceIssue(
                    severity=check["severity"],
                    category="data_security",
                    message=check["message"],
                    file=str(file_path),
                    line=line_num,
                )
                issues.append(issue)
 
        self.issues.extend(issues)
        return issues
 
    def check_pr_description(self, description: str) -> list[ComplianceIssue]:
        """PRの説明文にAI支援の記載があるかチェック"""
        issues = []
 
        # AI支援の記載確認
        ai_keywords = ["AI", "Copilot", "Claude", "GPT", "AI支援", "AI生成"]
        has_ai_mention = any(kw.lower() in description.lower() for kw in ai_keywords)
 
        if not has_ai_mention:
            issues.append(ComplianceIssue(
                severity="warning",
                category="transparency",
                message="PR説明にAI支援の範囲が記載されていません。"
                        "AIを使用した場合は記載してください。",
            ))
 
        self.issues.extend(issues)
        return issues
 
    def generate_report(self) -> str:
        """コンプライアンスレポートを生成"""
        critical = [i for i in self.issues if i.severity == "critical"]
        warnings = [i for i in self.issues if i.severity == "warning"]
        infos = [i for i in self.issues if i.severity == "info"]
 
        lines = [
            "# AIガバナンス コンプライアンスレポート\n",
            f"チェック日時: {datetime.now().isoformat()}",
            f"検出数: Critical {len(critical)}, Warning {len(warnings)}, Info {len(infos)}\n",
        ]
 
        if critical:
            lines.append("## Critical Issues（即座に対応が必要）\n")
            for issue in critical:
                lines.append(f"- [{issue.category}] {issue.message}")
                if issue.file:
                    lines.append(f"  ファイル: {issue.file}:{issue.line}")
 
        if warnings:
            lines.append("\n## Warnings（確認推奨）\n")
            for issue in warnings:
                lines.append(f"- [{issue.category}] {issue.message}")
                if issue.file:
                    lines.append(f"  ファイル: {issue.file}:{issue.line}")
 
        return "\n".join(lines)

# 演習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]

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