# シンプルなコーディングエージェントの実装
import anthropic
import subprocess
import os
 
class CodingAgent:
    def __init__(self, workspace: str):
        self.client = anthropic.Anthropic()
        self.workspace = workspace
        self.tools = [
            {
                "name": "read_file",
                "description": "ファイルの内容を読み取る",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "path": {"type": "string"}
                    },
                    "required": ["path"]
                }
            },
            {
                "name": "write_file",
                "description": "ファイルに内容を書き込む",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "path": {"type": "string"},
                        "content": {"type": "string"}
                    },
                    "required": ["path", "content"]
                }
            },
            {
                "name": "run_command",
                "description": "シェルコマンドを実行する（テスト、lint等）",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "command": {"type": "string"}
                    },
                    "required": ["command"]
                }
            },
            {
                "name": "search_code",
                "description": "コードベースをgrep検索する",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "pattern": {"type": "string"},
                        "file_pattern": {
                            "type": "string",
                            "description": "*.py, *.ts等"
                        }
                    },
                    "required": ["pattern"]
                }
            }
        ]
 
    def execute_tool(self, name: str, args: dict) -> str:
        full_path = os.path.join(self.workspace, args.get("path", ""))
 
        if name == "read_file":
            with open(full_path) as f:
                return f.read()
 
        elif name == "write_file":
            os.makedirs(os.path.dirname(full_path), exist_ok=True)
            with open(full_path, "w") as f:
                f.write(args["content"])
            return f"Written to {args['path']}"
 
        elif name == "run_command":
            result = subprocess.run(
                args["command"], shell=True,
                capture_output=True, text=True,
                cwd=self.workspace, timeout=60
            )
            output = result.stdout + result.stderr
            return output[:5000]
 
        elif name == "search_code":
            cmd = (
                f"grep -rn '{args['pattern']}' "
                f"--include='{args.get('file_pattern', '*')}' ."
            )
            result = subprocess.run(
                cmd, shell=True, capture_output=True, text=True,
                cwd=self.workspace
            )
            return result.stdout[:5000]
 
        return f"Unknown tool: {name}"
 
    def run(self, task: str) -> str:
        system = """あなたはシニアソフトウェアエンジニアです。
コードを変更する前に必ず既存コードを読んで理解してください。
テストを書いてから実装し、全テストが通ることを確認してください。"""
 
        messages = [{"role": "user", "content": task}]
 
        for _ in range(30):
            response = self.client.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=4096,
                system=system,
                tools=self.tools,
                messages=messages
            )
 
            if response.stop_reason == "end_turn":
                return response.content[0].text
 
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    result = self.execute_tool(block.name, block.input)
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result
                    })
 
            messages.append({
                "role": "assistant",
                "content": response.content
            })
            messages.append({"role": "user", "content": tool_results})
 
        return "最大ステップ数に達しました"

# TDDパターンのコーディングエージェント
class TDDAgent(CodingAgent):
    def implement_feature(self, feature_description: str) -> str:
        """テスト駆動で機能を実装"""
        return self.run(f"""
以下の機能をTDD（テスト駆動開発）で実装してください。
 
機能: {feature_description}
 
手順:
1. まず既存のコードベースを調査してディレクトリ構造とコードスタイルを理解
2. テストファイルを作成（テストが失敗する状態 = RED）
3. テストを実行して失敗を確認
4. 最小限の実装でテストを通す（GREEN）
5. テストを実行して全て通ることを確認
6. 必要に応じてリファクタリング（REFACTOR）
7. 最終的に全テストが通ることを確認
 
重要: 各ステップで実際にテストを実行してください。
""")

# コードレビューエージェント
class CodeReviewAgent:
    def __init__(self):
        self.client = anthropic.Anthropic()
 
    def review_diff(self, diff: str) -> str:
        """差分をレビューして改善点を指摘"""
        return self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4096,
            messages=[{"role": "user", "content": f"""
以下のコード差分をレビューしてください。
 
```diff
{diff}

class MigrationAgent(CodingAgent):
    """言語・フレームワークのマイグレーションエージェント"""
 
    def migrate_dependency(
        self,
        old_package: str,
        new_package: str,
        migration_guide: str = ""
    ) -> str:
        """依存パッケージのマイグレーション"""
        return self.run(f"""
以下のパッケージマイグレーションを実施してください。
 
変更前: {old_package}
変更後: {new_package}
{f'マイグレーションガイド: {migration_guide}' if migration_guide else ''}
 
手順:
1. 現在のコードベースで {old_package} の使用箇所を全て検索
2. 各使用箇所の変更方法を計画
3. パッケージの依存関係を更新（package.json, requirements.txt等）
4. コードを1ファイルずつ変更
5. 各ファイル変更後にテストを実行
6. 全テストが通ることを確認
7. 変更概要のレポートを出力
 
重要:
- APIの互換性の違いに注意
- deprecated な機能の代替手段を使用
- 型定義の変更にも対応
""")
 
    def upgrade_framework(
        self,
        framework: str,
        from_version: str,
        to_version: str
    ) -> str:
        """フレームワークのバージョンアップグレード"""
        return self.run(f"""
{framework} を v{from_version} から v{to_version} にアップグレードしてください。
 
手順:
1. 破壊的変更のリストを確認
2. 影響を受けるファイルを特定
3. 依存関係のバージョンを更新
4. コードの互換性を修正
5. deprecated 警告を解消
6. テストを実行して確認
7. 変更ログをまとめる
""")

# コーディングエージェントのためのCLAUDE.md例
CLAUDE_MD = """
# プロジェクト固有のルール
 
## テクノロジースタック
- Backend: Python 3.12, FastAPI, SQLAlchemy
- Frontend: TypeScript, React 19, Tailwind CSS
- DB: PostgreSQL 16
- テスト: pytest, vitest
 
## コーディング規約
- Python: Black + isort + mypy strict
- TypeScript: ESLint + Prettier
- コミットメッセージ: Conventional Commits
 
## ディレクトリ構造
- backend/src/ : バックエンドソースコード
- backend/tests/ : バックエンドテスト
- frontend/src/ : フロントエンドソースコード
- frontend/tests/ : フロントエンドテスト
 
## 重要な注意事項
- DB変更時は必ずAlembicマイグレーションを作成
- APIエンドポイント追加時はOpenAPIスキーマを更新
- 環境変数は .env.example に追記
"""

# バグ修正用プロンプト
BUG_FIX_PROMPT = """
## バグ修正リクエスト
 
### 症状
{症状の説明}
 
### 再現手順
{再現手順}
 
### 期待される動作
{期待される動作}
 
### エラーログ（あれば）

# GitHub Actions でのコーディングエージェント活用例
"""
name: Agent-Assisted 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 PR diff
        id: diff
        run: |
          git diff origin/${{ github.base_ref }}...HEAD > pr.diff
          echo "diff_file=pr.diff" >> $GITHUB_OUTPUT
 
      - name: AI Code Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          python scripts/ai_review.py \
            --diff-file pr.diff \
            --output review.md
 
      - name: Post Review Comment
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review.md', 'utf8');
            await github.rest.pulls.createReview({
              owner: context.repo.owner,
              repo: context.repo.repo,
              pull_number: context.payload.pull_request.number,
              body: review,
              event: 'COMMENT'
            });
"""

class DebugAgent(CodingAgent):
    """デバッグに特化したエージェント"""
 
    def diagnose_error(self, error_log: str) -> str:
        """エラーログから原因を診断"""
        return self.run(f"""
以下のエラーを診断し、修正してください。
 
エラーログ:

class CodingAgentEvaluator:
    """コーディングエージェントのパフォーマンス評価"""
 
    def evaluate_task(
        self,
        task_description: str,
        agent_output: dict,
        ground_truth: dict
    ) -> dict:
        """タスク実行結果を評価"""
        metrics = {}
 
        # 1. 正確性: テストの通過率
        metrics["test_pass_rate"] = self._run_tests(
            agent_output["modified_files"]
        )
 
        # 2. コード品質: 静的解析スコア
        metrics["lint_score"] = self._run_linter(
            agent_output["modified_files"]
        )
 
        # 3. 効率性: ステップ数とトークン消費
        metrics["total_steps"] = agent_output["steps"]
        metrics["total_tokens"] = agent_output["tokens"]
        metrics["total_cost"] = agent_output["cost"]
 
        # 4. 差分の適切さ: 不要な変更がないか
        metrics["unnecessary_changes"] = self._check_unnecessary_changes(
            agent_output["diff"],
            ground_truth.get("expected_diff")
        )
 
        # 5. 時間: 実行時間
        metrics["execution_time"] = agent_output["duration_seconds"]
 
        return metrics
 
    def benchmark_suite(
        self,
        agent,
        test_cases: list[dict]
    ) -> dict:
        """ベンチマークスイートの実行"""
        results = []
 
        for case in test_cases:
            try:
                output = agent.run(case["task"])
                metrics = self.evaluate_task(
                    case["task"], output, case["expected"]
                )
                results.append({
                    "case_id": case["id"],
                    "status": "completed",
                    "metrics": metrics
                })
            except Exception as e:
                results.append({
                    "case_id": case["id"],
                    "status": "error",
                    "error": str(e)
                })
 
        # 集計
        completed = [r for r in results if r["status"] == "completed"]
        return {
            "total_cases": len(test_cases),
            "completed": len(completed),
            "success_rate": (
                sum(1 for r in completed
                    if r["metrics"]["test_pass_rate"] == 1.0)
                / len(completed) if completed else 0
            ),
            "avg_steps": (
                sum(r["metrics"]["total_steps"] for r in completed)
                / len(completed) if completed else 0
            ),
            "avg_cost": (
                sum(r["metrics"]["total_cost"] for r in completed)
                / len(completed) if completed else 0
            ),
            "details": results
        }

class SecureCodingAgent(CodingAgent):
    """セキュリティ対策が組み込まれたコーディングエージェント"""
 
    # 実行禁止コマンド
    BLOCKED_COMMANDS = [
        r"rm\s+-rf\s+/",
        r"curl.*\|\s*bash",
        r"wget.*\|\s*sh",
        r"chmod\s+777",
        r"sudo\s+",
        r"eval\s*\(",
    ]
 
    # 書き込み禁止パス
    PROTECTED_PATHS = [
        ".env",
        ".git/",
        "credentials",
        "secrets",
        "node_modules/",
        "__pycache__/",
    ]
 
    def execute_tool(self, name: str, args: dict) -> str:
        # コマンドの安全性チェック
        if name == "run_command":
            for pattern in self.BLOCKED_COMMANDS:
                if re.search(pattern, args["command"]):
                    return f"セキュリティポリシーにより拒否: {args['command']}"
 
        # 書き込みパスのチェック
        if name == "write_file":
            for protected in self.PROTECTED_PATHS:
                if protected in args.get("path", ""):
                    return f"保護対象のパスへの書き込み拒否: {args['path']}"
 
        return super().execute_tool(name, args)

class SecurityReviewAgent:
    """セキュリティ観点でのコードレビュー"""
 
    SECURITY_CHECKS = {
        "sql_injection": {
            "patterns": [
                r"f\".*SELECT.*{",
                r"f'.*SELECT.*{",
                r"\.format\(.*SELECT",
                r"\+.*SELECT.*\+",
            ],
            "severity": "critical",
            "recommendation": "パラメータ化クエリを使用してください"
        },
        "xss": {
            "patterns": [
                r"innerHTML\s*=",
                r"dangerouslySetInnerHTML",
                r"document\.write\(",
            ],
            "severity": "high",
            "recommendation": "ユーザー入力をサニタイズしてください"
        },
        "hardcoded_secrets": {
            "patterns": [
                r"(api_key|apikey|secret|password|token)\s*=\s*['\"]",
                r"(AWS_ACCESS_KEY|ANTHROPIC_API_KEY)\s*=\s*['\"]",
            ],
            "severity": "critical",
            "recommendation": "環境変数またはシークレットマネージャーを使用してください"
        },
        "insecure_deserialization": {
            "patterns": [
                r"pickle\.loads?\(",
                r"yaml\.load\(",
                r"eval\(",
                r"exec\(",
            ],
            "severity": "high",
            "recommendation": "安全なデシリアライズ方法を使用してください"
        }
    }
 
    def scan_code(self, code: str, file_path: str) -> list[dict]:
        """コードをスキャンしてセキュリティ問題を検出"""
        findings = []
 
        for check_name, check in self.SECURITY_CHECKS.items():
            for pattern in check["patterns"]:
                matches = re.finditer(pattern, code)
                for match in matches:
                    line_num = code[:match.start()].count("\n") + 1
                    findings.append({
                        "check": check_name,
                        "file": file_path,
                        "line": line_num,
                        "severity": check["severity"],
                        "match": match.group(),
                        "recommendation": check["recommendation"]
                    })
 
        return findings

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

class ScaffoldAgent(CodingAgent):
    """プロジェクトの初期構成を自動生成"""
 
    def scaffold_project(
        self,
        project_type: str,
        name: str,
        features: list[str]
    ) -> str:
        """プロジェクトテンプレートを生成"""
        return self.run(f"""
以下の仕様でプロジェクトの初期構成を作成してください。
 
プロジェクトタイプ: {project_type}
プロジェクト名: {name}
必要な機能: {', '.join(features)}
 
作成するもの:
1. ディレクトリ構造
2. 設定ファイル（package.json / pyproject.toml 等）
3. Docker関連ファイル（Dockerfile, docker-compose.yml）
4. CI/CD設定（.github/workflows/）
5. テスト設定
6. Lint/フォーマッター設定
7. README.md
8. .gitignore
9. サンプルコード（Hello World レベル）
10. サンプルテスト
 
各ファイルにはコメントで設計意図を記述してください。
""")

class DocGenerationAgent(CodingAgent):
    """コードからドキュメントを自動生成"""
 
    def generate_api_docs(self, source_dir: str) -> str:
        """APIドキュメントを生成"""
        return self.run(f"""
以下のディレクトリのAPIコードを読んで、
OpenAPI仕様のドキュメントを生成してください。
 
ソースディレクトリ: {source_dir}
 
出力:
1. 各エンドポイントの説明
2. リクエスト/レスポンスのスキーマ
3. 認証方法
4. エラーレスポンスの一覧
5. 使用例（curlコマンド）
 
形式: OpenAPI 3.0 YAML
""")
 
    def generate_changelog(self, from_tag: str, to_tag: str) -> str:
        """Git履歴からCHANGELOGを生成"""
        return self.run(f"""
Gitの履歴から {from_tag} 以降 {to_tag} までの
変更履歴（CHANGELOG）を生成してください。
 
手順:
1. git log {from_tag}..{to_tag} でコミット一覧を取得
2. コミットメッセージをカテゴリ分類（feat, fix, chore等）
3. 影響するファイルから変更の重要度を判定
4. CHANGELOG.md形式で出力
 
出力形式: Keep a Changelog 形式
""")

class TestCoverageAgent(CodingAgent):
    """テストカバレッジを分析して不足を補完"""
 
    def improve_coverage(
        self,
        target_dir: str,
        min_coverage: float = 80.0
    ) -> str:
        """テストカバレッジを目標値まで改善"""
        return self.run(f"""
以下のディレクトリのテストカバレッジを改善してください。
 
対象ディレクトリ: {target_dir}
目標カバレッジ: {min_coverage}%
 
手順:
1. 現在のカバレッジレポートを生成して確認
2. カバレッジが低いファイル/関数を特定
3. 以下の優先度でテストを追加:
   a. カバレッジ0%の関数
   b. 条件分岐が網羅されていない関数
   c. エッジケースのテスト不足
   d. エラーハンドリングのテスト不足
4. 各テスト追加後にカバレッジを再計測
5. 目標カバレッジに到達するまで繰り返す
 
注意:
- カバレッジの数値だけでなく、意味のあるテストを書く
- 各テストにはテストの意図をコメントで記述
- 既存のテストスタイルに合わせる
""")