# .github/workflows/ci.yml
name: CI Pipeline
 
on:
  pull_request:
    branches: [main, develop]
  push:
    branches: [main]
 
# 同一PRの実行中ワークフローをキャンセル
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
 
jobs:
  # ===== Stage 1: Fast Feedback =====
  lint-and-format:
    runs-on: ubuntu-latest
    timeout-minutes: 5
    steps:
      - uses: actions/checkout@v4
 
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
          cache: 'pip'
 
      - name: Install dependencies
        run: pip install -r requirements-dev.txt
 
      - name: Ruff (Lint + Format)
        run: |
          ruff check src/ tests/
          ruff format --check src/ tests/
 
      - name: MyPy (Type Check)
        run: mypy src/ --strict
 
  # ===== Stage 2: Core Verification =====
  unit-tests:
    needs: lint-and-format
    runs-on: ubuntu-latest
    timeout-minutes: 10
    strategy:
      matrix:
        python-version: ['3.11', '3.12']
    steps:
      - uses: actions/checkout@v4
 
      - name: Setup Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
          cache: 'pip'
 
      - name: Install dependencies
        run: pip install -r requirements.txt -r requirements-dev.txt
 
      - name: Unit Tests with Coverage
        run: |
          pytest tests/unit/ \
            --cov=src \
            --cov-report=xml \
            --cov-report=term-missing \
            --cov-fail-under=80 \
            --junitxml=test-results.xml \
            -x -q \
            --timeout=30
 
      - name: Upload Coverage to Codecov
        if: matrix.python-version == '3.12'
        uses: codecov/codecov-action@v4
        with:
          file: coverage.xml
          fail_ci_if_error: true
          token: ${{ secrets.CODECOV_TOKEN }}
 
      - name: Upload Test Results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: test-results-${{ matrix.python-version }}
          path: test-results.xml
 
  # ===== Stage 3: Extended Verification =====
  integration-tests:
    needs: unit-tests
    runs-on: ubuntu-latest
    timeout-minutes: 15
    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_PASSWORD: test_password
          POSTGRES_DB: test_db
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
 
      redis:
        image: redis:7
        ports:
          - 6379:6379
 
    steps:
      - uses: actions/checkout@v4
 
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
          cache: 'pip'
 
      - name: Install dependencies
        run: pip install -r requirements.txt -r requirements-dev.txt
 
      - name: Integration Tests
        env:
          DATABASE_URL: postgresql://postgres:test_password@localhost:5432/test_db
          REDIS_URL: redis://localhost:6379
        run: pytest tests/integration/ -v --timeout=60
 
  security-scan:
    needs: unit-tests
    runs-on: ubuntu-latest
    timeout-minutes: 10
    steps:
      - uses: actions/checkout@v4
 
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
 
      - name: Install dependencies
        run: pip install -r requirements.txt bandit safety
 
      - name: Bandit (SAST)
        run: bandit -r src/ -f json -o bandit-report.json -ll
        continue-on-error: true
 
      - name: Safety (Dependency Vulnerabilities)
        run: safety check --json --output safety-report.json
 
      - name: Upload Security Reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: security-reports
          path: |
            bandit-report.json
            safety-report.json
 
  # ===== Stage 4: Build =====
  build:
    needs: [integration-tests, security-scan]
    runs-on: ubuntu-latest
    timeout-minutes: 10
    steps:
      - uses: actions/checkout@v4
 
      - name: Build Docker Image
        run: |
          docker build \
            --tag ${{ github.repository }}:${{ github.sha }} \
            --label "org.opencontainers.image.revision=${{ github.sha }}" \
            .
 
      - name: Trivy Vulnerability Scan
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: ${{ github.repository }}:${{ github.sha }}
          format: 'sarif'
          output: 'trivy-results.sarif'
          severity: 'CRITICAL,HIGH'

# .pre-commit-config.yaml
# ローカル開発での品質チェック（CIの前段階）
repos:
  # Ruff: Lint + Format (Python)
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.3.0
    hooks:
      - id: ruff
        args: [--fix, --exit-non-zero-on-fix]
      - id: ruff-format
 
  # MyPy: Type Check
  - repo: https://github.com/pre-commit/mirrors-mypy
    rev: v1.8.0
    hooks:
      - id: mypy
        additional_dependencies: [types-requests, types-pyyaml]
        args: [--strict]
 
  # 汎用チェック
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.5.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
      - id: check-toml
      - id: check-json
      - id: check-added-large-files
        args: ['--maxkb=500']
      - id: detect-private-key
      - id: check-merge-conflict
      - id: no-commit-to-branch
        args: [--branch, main, --branch, master]
 
  # コミットメッセージ規約
  - repo: https://github.com/compilerla/conventional-pre-commit
    rev: v3.1.0
    hooks:
      - id: conventional-pre-commit
        stages: [commit-msg]
        args: [feat, fix, refactor, docs, test, chore, ci, perf]
 
  # セキュリティ
  - repo: https://github.com/Yelp/detect-secrets
    rev: v1.4.0
    hooks:
      - id: detect-secrets
        args: ['--baseline', '.secrets.baseline']

"""DORA メトリクス収集フレームワーク"""
import subprocess
import json
from datetime import datetime, timedelta
from dataclasses import dataclass, field
from typing import Optional
 
 
@dataclass
class DORAMetrics:
    """DORA メトリクスのデータモデル"""
    # 計測期間
    period_start: datetime
    period_end: datetime
 
    # 1. デプロイ頻度
    deploy_count: int = 0
    deploy_frequency_per_day: float = 0.0
 
    # 2. リードタイム
    lead_times_hours: list[float] = field(default_factory=list)
 
    # 3. 変更失敗率
    total_changes: int = 0
    failed_changes: int = 0
 
    # 4. 復旧時間
    restore_times_hours: list[float] = field(default_factory=list)
 
    @property
    def period_days(self) -> int:
        return (self.period_end - self.period_start).days
 
    @property
    def avg_lead_time_hours(self) -> float:
        if not self.lead_times_hours:
            return 0.0
        return sum(self.lead_times_hours) / len(self.lead_times_hours)
 
    @property
    def median_lead_time_hours(self) -> float:
        if not self.lead_times_hours:
            return 0.0
        sorted_times = sorted(self.lead_times_hours)
        n = len(sorted_times)
        if n % 2 == 0:
            return (sorted_times[n // 2 - 1] + sorted_times[n // 2]) / 2
        return sorted_times[n // 2]
 
    @property
    def change_failure_rate(self) -> float:
        if self.total_changes == 0:
            return 0.0
        return (self.failed_changes / self.total_changes) * 100
 
    @property
    def avg_restore_time_hours(self) -> float:
        if not self.restore_times_hours:
            return 0.0
        return sum(self.restore_times_hours) / len(self.restore_times_hours)
 
    def classify(self, metric: str) -> str:
        """指標のパフォーマンスレベルを判定"""
        classifications = {
            "deploy_frequency": [
                (1.0, "Elite"),    # 日次以上
                (0.14, "High"),    # 週次以上
                (0.03, "Medium"),  # 月次以上
                (0.0, "Low"),
            ],
            "lead_time": [
                (1.0, "Elite"),    # 1時間以内
                (24.0, "High"),    # 1日以内
                (168.0, "Medium"), # 1週間以内
                (float("inf"), "Low"),
            ],
            "change_failure_rate": [
                (5.0, "Elite"),
                (15.0, "High"),
                (30.0, "Medium"),
                (float("inf"), "Low"),
            ],
            "restore_time": [
                (1.0, "Elite"),
                (24.0, "High"),
                (168.0, "Medium"),
                (float("inf"), "Low"),
            ],
        }
 
        if metric == "deploy_frequency":
            value = self.deploy_frequency_per_day
            for threshold, level in classifications[metric]:
                if value >= threshold:
                    return level
        elif metric == "lead_time":
            value = self.median_lead_time_hours
            for threshold, level in classifications[metric]:
                if value <= threshold:
                    return level
        elif metric == "change_failure_rate":
            value = self.change_failure_rate
            for threshold, level in classifications[metric]:
                if value <= threshold:
                    return level
        elif metric == "restore_time":
            value = self.avg_restore_time_hours
            for threshold, level in classifications[metric]:
                if value <= threshold:
                    return level
 
        return "Low"
 
    @property
    def overall_level(self) -> str:
        """総合パフォーマンスレベル"""
        levels = {
            "Elite": 4, "High": 3, "Medium": 2, "Low": 1
        }
        metrics = [
            self.classify("deploy_frequency"),
            self.classify("lead_time"),
            self.classify("change_failure_rate"),
            self.classify("restore_time"),
        ]
        avg_score = sum(levels[m] for m in metrics) / len(metrics)
 
        if avg_score >= 3.5: return "Elite"
        elif avg_score >= 2.5: return "High"
        elif avg_score >= 1.5: return "Medium"
        else: return "Low"
 
 
def collect_dora_metrics(
    repo_path: str,
    days: int = 30,
    deploy_tag_pattern: str = "v*"
) -> DORAMetrics:
    """Git + GitHub CLI からDORAメトリクスを収集"""
    end = datetime.now()
    start = end - timedelta(days=days)
    since = start.isoformat()
 
    metrics = DORAMetrics(period_start=start, period_end=end)
 
    # 1. デプロイ頻度 (タグベース)
    result = subprocess.run(
        ["git", "tag", "-l", deploy_tag_pattern, "--sort=-creatordate",
         "--format=%(creatordate:iso)"],
        capture_output=True, text=True, cwd=repo_path
    )
    deploy_dates = []
    for line in result.stdout.strip().split("\n"):
        if line:
            try:
                dt = datetime.fromisoformat(line.strip().split("+")[0].strip())
                if dt >= start:
                    deploy_dates.append(dt)
            except ValueError:
                continue
 
    metrics.deploy_count = len(deploy_dates)
    metrics.deploy_frequency_per_day = metrics.deploy_count / max(days, 1)
 
    # 2. リードタイム (PR作成 → マージまでの時間)
    try:
        result = subprocess.run(
            ["gh", "pr", "list", "--state", "merged", "--limit", "100",
             "--json", "createdAt,mergedAt"],
            capture_output=True, text=True, cwd=repo_path, timeout=30
        )
        if result.returncode == 0:
            prs = json.loads(result.stdout)
            for pr in prs:
                created = datetime.fromisoformat(pr["createdAt"].replace("Z", "+00:00"))
                merged = datetime.fromisoformat(pr["mergedAt"].replace("Z", "+00:00"))
                if created >= start.replace(tzinfo=created.tzinfo):
                    lead_time = (merged - created).total_seconds() / 3600
                    metrics.lead_times_hours.append(lead_time)
    except (subprocess.TimeoutExpired, FileNotFoundError):
        pass
 
    # 3. 変更失敗率 (revert / hotfix コミットの割合)
    result = subprocess.run(
        ["git", "log", "--oneline", "--since", since],
        capture_output=True, text=True, cwd=repo_path
    )
    all_commits = [
        line for line in result.stdout.strip().split("\n") if line
    ]
    metrics.total_changes = len(all_commits)
 
    result = subprocess.run(
        ["git", "log", "--oneline", "--since", since,
         "--grep=revert\\|hotfix\\|rollback", "-i"],
        capture_output=True, text=True, cwd=repo_path
    )
    failed_commits = [
        line for line in result.stdout.strip().split("\n") if line
    ]
    metrics.failed_changes = len(failed_commits)
 
    return metrics
 
 
def print_dora_dashboard(metrics: DORAMetrics) -> None:
    """DORAメトリクスダッシュボード"""
    width = 64
    print("=" * width)
    print("  DORA メトリクスダッシュボード".center(width))
    print(f"  期間: {metrics.period_start.strftime('%Y-%m-%d')} "
          f"~ {metrics.period_end.strftime('%Y-%m-%d')} "
          f"({metrics.period_days}日間)".center(width))
    print("=" * width)
 
    # デプロイ頻度
    level = metrics.classify("deploy_frequency")
    print(f"\n  [1] デプロイ頻度")
    print(f"      回数: {metrics.deploy_count} 回")
    print(f"      頻度: {metrics.deploy_frequency_per_day:.2f} 回/日")
    print(f"      レベル: {level}")
 
    # リードタイム
    level = metrics.classify("lead_time")
    print(f"\n  [2] リードタイム (PR作成→マージ)")
    print(f"      平均: {metrics.avg_lead_time_hours:.1f} 時間")
    print(f"      中央値: {metrics.median_lead_time_hours:.1f} 時間")
    print(f"      レベル: {level}")
 
    # 変更失敗率
    level = metrics.classify("change_failure_rate")
    print(f"\n  [3] 変更失敗率")
    print(f"      総変更: {metrics.total_changes} 件")
    print(f"      失敗: {metrics.failed_changes} 件")
    print(f"      失敗率: {metrics.change_failure_rate:.1f}%")
    print(f"      レベル: {level}")
 
    # 復旧時間
    level = metrics.classify("restore_time")
    print(f"\n  [4] 復旧時間")
    print(f"      平均: {metrics.avg_restore_time_hours:.1f} 時間")
    print(f"      レベル: {level}")
 
    # 総合
    print(f"\n" + "-" * width)
    overall = metrics.overall_level
    print(f"  総合パフォーマンス: {overall}")
    print("=" * width)

"""品質メトリクスの統合ダッシュボード"""
from dataclasses import dataclass, field
from datetime import datetime
 
 
@dataclass
class QualitySnapshot:
    """ある時点の品質メトリクスのスナップショット"""
    timestamp: datetime
 
    # コード品質
    avg_complexity: float
    duplication_percent: float
    type_coverage_percent: float
 
    # テスト
    test_coverage_percent: float
    test_count: int
    test_pass_rate: float       # テスト成功率 (%)
    test_execution_sec: float
 
    # セキュリティ
    known_vulnerabilities: int
    security_hotspots: int
 
    # 保守性
    todo_fixme_count: int
    outdated_deps: int
    avg_file_size_lines: float
 
 
@dataclass
class QualityTrend:
    """品質メトリクスのトレンド分析"""
    snapshots: list[QualitySnapshot] = field(default_factory=list)
 
    def add_snapshot(self, snapshot: QualitySnapshot) -> None:
        self.snapshots.append(snapshot)
        self.snapshots.sort(key=lambda s: s.timestamp)
 
    def get_trend(self, metric: str, periods: int = 6) -> list[tuple[datetime, float]]:
        """指定メトリクスのトレンドデータを取得"""
        recent = self.snapshots[-periods:]
        return [(s.timestamp, getattr(s, metric, 0.0)) for s in recent]
 
    def detect_degradation(
        self,
        metric: str,
        threshold_percent: float = 10.0,
        higher_is_better: bool = True
    ) -> bool:
        """品質劣化を検出
 
        直近2回のスナップショットを比較し、
        threshold_percent 以上の劣化があれば True
        """
        if len(self.snapshots) < 2:
            return False
 
        current = getattr(self.snapshots[-1], metric, 0.0)
        previous = getattr(self.snapshots[-2], metric, 0.0)
 
        if previous == 0:
            return False
 
        change_percent = ((current - previous) / abs(previous)) * 100
 
        if higher_is_better:
            return change_percent < -threshold_percent
        else:
            return change_percent > threshold_percent
 
    def generate_report(self) -> str:
        """品質トレンドレポートを生成"""
        if not self.snapshots:
            return "データなし"
 
        current = self.snapshots[-1]
        lines = [
            "=" * 60,
            "  品質トレンドレポート",
            f"  時点: {current.timestamp.strftime('%Y-%m-%d %H:%M')}",
            "=" * 60,
        ]
 
        # 劣化検出
        degradations = []
        checks = [
            ("test_coverage_percent", "テストカバレッジ", True),
            ("avg_complexity", "平均複雑度", False),
            ("duplication_percent", "コード重複率", False),
            ("known_vulnerabilities", "既知脆弱性", False),
            ("outdated_deps", "古い依存関係", False),
        ]
 
        for metric, name, higher_is_better in checks:
            if self.detect_degradation(metric, 10.0, higher_is_better):
                degradations.append(name)
 
        if degradations:
            lines.append(f"\n  [ALERT] 品質劣化検出:")
            for d in degradations:
                lines.append(f"    - {d}")
        else:
            lines.append(f"\n  [OK] 品質劣化なし")
 
        lines.append("=" * 60)
        return "\n".join(lines)

# .github/workflows/quality-trend.yml
name: Quality Trend Tracking
 
on:
  schedule:
    - cron: '0 9 * * 1'  # 毎週月曜9時
  workflow_dispatch:
 
jobs:
  collect-metrics:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
 
      - name: Install tools
        run: |
          pip install -r requirements.txt -r requirements-dev.txt
          pip install radon
 
      - name: Collect quality metrics
        run: |
          python -c "
          import json
          from datetime import datetime
 
          metrics = {
            'timestamp': datetime.now().isoformat(),
            'test_coverage': $(pytest --cov=src --cov-report=json -q 2>/dev/null; python -c "import json; print(json.load(open('coverage.json'))['totals']['percent_covered'])" 2>/dev/null || echo 0),
            'avg_complexity': $(radon cc src/ -a -j | python -c "import json,sys; d=json.load(sys.stdin); print(d.get('average',0) if isinstance(d,dict) else 0)" 2>/dev/null || echo 0),
            'todo_count': $(grep -r -c -E 'TODO|FIXME|HACK' src/ 2>/dev/null | awk -F: '{s+=\$2}END{print s+0}'),
          }
 
          # トレンドファイルに追加
          try:
            with open('quality-trend.json') as f:
              trend = json.load(f)
          except FileNotFoundError:
            trend = []
 
          trend.append(metrics)
 
          # 直近52週分を保持
          trend = trend[-52:]
 
          with open('quality-trend.json', 'w') as f:
            json.dump(trend, f, indent=2)
 
          print(json.dumps(metrics, indent=2))
          "
 
      - name: Commit trend data
        run: |
          git config user.name "github-actions[bot]"
          git config user.email "github-actions[bot]@users.noreply.github.com"
          git add quality-trend.json
          git diff --staged --quiet || git commit -m "chore: update quality trend data"
          git push

"""改善サイクルの構造化フレームワーク"""
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
 
 
class CyclePhase(Enum):
    PLAN = "plan"
    DO = "do"
    CHECK = "check"
    ACT = "act"
 
 
@dataclass
class ImprovementGoal:
    """改善目標"""
    metric: str
    current_value: float
    target_value: float
    deadline: datetime
    owner: str
    actions: list[str] = field(default_factory=list)
 
    @property
    def progress_percent(self) -> float:
        if self.target_value == self.current_value:
            return 100.0
        return min(100.0, max(0.0,
            abs(self.current_value - self.target_value) /
            abs(self.target_value - self.current_value) * 100
        ))
 
 
@dataclass
class ImprovementCycle:
    """品質改善の PDCA サイクル管理"""
    cycle_id: str
    phase: CyclePhase = CyclePhase.PLAN
    goals: list[ImprovementGoal] = field(default_factory=list)
    learnings: list[str] = field(default_factory=list)
 
    def plan(self, current_metrics: dict, improvement_areas: list[str]) -> dict:
        """Plan: 現状分析と改善目標設定
 
        ステップ:
        1. 現状メトリクスの分析
        2. ボトルネックの特定
        3. 改善目標の設定 (SMART原則)
        4. アクションプランの策定
        """
        targets = {}
        for area in improvement_areas:
            current = current_metrics.get(area, 0)
 
            # 改善目標: 現状から10-30%改善
            if area in ("test_coverage", "deploy_frequency"):
                target = min(current * 1.2, 95.0)  # 20%向上、上限95%
            elif area in ("avg_complexity", "lead_time_hours"):
                target = current * 0.8  # 20%削減
            elif area == "change_failure_rate":
                target = max(current * 0.7, 5.0)  # 30%削減、下限5%
            else:
                target = current * 1.1
 
            targets[area] = {
                "current": current,
                "target": round(target, 1),
                "improvement": f"{abs((target - current) / max(current, 0.1) * 100):.0f}%",
            }
 
        self.phase = CyclePhase.PLAN
        return {"current_metrics": current_metrics, "targets": targets}
 
    def do(self, actions: list[dict]) -> list[str]:
        """Do: 改善アクションの実施
 
        各アクションは以下の形式:
        {"name": str, "owner": str, "deadline": str, "execute": callable}
        """
        results = []
        self.phase = CyclePhase.DO
 
        for action in actions:
            try:
                action["execute"]()
                results.append(f"[OK] {action['name']} (担当: {action['owner']})")
            except Exception as e:
                results.append(f"[NG] {action['name']}: {e}")
 
        return results
 
    def check(self, targets: dict, actual_metrics: dict) -> dict:
        """Check: 効果測定
 
        各目標に対する達成度を評価
        """
        self.phase = CyclePhase.CHECK
        results = {}
 
        for metric, target_info in targets.items():
            target_value = target_info["target"]
            actual_value = actual_metrics.get(metric, 0)
            current_value = target_info["current"]
 
            # 改善方向に応じた達成判定
            if metric in ("test_coverage", "deploy_frequency"):
                achieved = actual_value >= target_value
                improvement = actual_value - current_value
            else:
                achieved = actual_value <= target_value
                improvement = current_value - actual_value
 
            results[metric] = {
                "target": target_value,
                "actual": actual_value,
                "achieved": achieved,
                "improvement": round(improvement, 1),
            }
 
        return results
 
    def act(self, check_results: dict) -> dict:
        """Act: 標準化 or 方針修正
 
        達成: 改善をプロセスに組み込み（標準化）
        未達: 原因分析 → 次サイクルの Plan に反映
        """
        self.phase = CyclePhase.ACT
        actions = {}
 
        for metric, result in check_results.items():
            if result["achieved"]:
                actions[metric] = {
                    "action": "standardize",
                    "detail": f"{metric}: 改善をCI/CDパイプラインに組み込み、"
                              f"閾値を {result['actual']} に更新",
                }
            else:
                actions[metric] = {
                    "action": "adjust",
                    "detail": f"{metric}: 原因分析を実施。"
                              f"目標={result['target']}, 実績={result['actual']}。"
                              f"次サイクルで対策を強化",
                }
                self.learnings.append(
                    f"{metric}: 目標未達。Gap={result['target'] - result['actual']:.1f}"
                )
 
        return actions

"""レトロスペクティブの構造化"""
from dataclasses import dataclass, field
from datetime import date
 
 
@dataclass
class RetroItem:
    """レトロスペクティブのアイテム"""
    category: str   # "keep", "problem", "try"
    description: str
    owner: str = ""
    deadline: str = ""
    status: str = "open"  # open, achieved, not_achieved, carried_over
 
    def __str__(self) -> str:
        prefix = {"keep": "+", "problem": "-", "try": "[ ]"}
        return f"  {prefix.get(self.category, '?')} {self.description}"
 
 
@dataclass
class SprintRetro:
    """スプリントレトロスペクティブ"""
    sprint_name: str
    date: date
    items: list[RetroItem] = field(default_factory=list)
    metrics: dict = field(default_factory=dict)
    previous_try_results: list[dict] = field(default_factory=list)
 
    @property
    def keeps(self) -> list[RetroItem]:
        return [i for i in self.items if i.category == "keep"]
 
    @property
    def problems(self) -> list[RetroItem]:
        return [i for i in self.items if i.category == "problem"]
 
    @property
    def tries(self) -> list[RetroItem]:
        return [i for i in self.items if i.category == "try"]
 
    def carry_over_unfinished(self) -> list[RetroItem]:
        """未達のTryを次回に繰り越し"""
        return [
            RetroItem(
                category="try",
                description=f"[繰越] {item.description}",
                owner=item.owner,
                deadline=item.deadline,
                status="carried_over",
            )
            for item in self.tries
            if item.status == "not_achieved"
        ]
 
    def effectiveness_score(self) -> float:
        """レトロスペクティブの効果スコア
 
        前回のTryのうち達成されたものの割合
        """
        if not self.previous_try_results:
            return 0.0
 
        achieved = sum(
            1 for r in self.previous_try_results
            if r.get("status") == "achieved"
        )
        return (achieved / len(self.previous_try_results)) * 100

"""改善プラクティスの実装パターン"""
 
 
class ImprovementPractices:
    """チーム改善プラクティス集"""
 
    @staticmethod
    def blameless_postmortem_template() -> str:
        """ブレームレス・ポストモーテムのテンプレート"""
        return """
        ========================================
        ポストモーテム: [インシデント名]
        日時: [YYYY-MM-DD]
        ========================================
 
        ## タイムライン
        - HH:MM 検知: [何が起きたか]
        - HH:MM 対応開始: [誰が何をしたか]
        - HH:MM 解決: [どう解決したか]
 
        ## 影響範囲
        - 影響ユーザー数: [N人]
        - ダウンタイム: [N分]
        - 収益影響: [推定金額]
 
        ## 根本原因
        [5 Whys 分析]
        Why 1: なぜサービスが停止した？→ OOM Kill
        Why 2: なぜメモリ不足？→ メモリリーク
        Why 3: なぜリークを検知できなかった？→ 監視がなかった
        Why 4: なぜ監視がなかった？→ 設定を忘れていた
        Why 5: なぜ忘れた？→ チェックリストがなかった
 
        ## アクションアイテム
        - [ ] メモリ監視アラートの追加 (担当: Alice, 期限: MM/DD)
        - [ ] デプロイ前チェックリストに監視確認を追加 (担当: Bob)
        - [ ] メモリリーク検出のテスト追加 (担当: Carol)
 
        ## 学び
        - [今回の教訓を文書化]
 
        ## 注意: ポストモーテムは「誰のせいか」ではなく
                「システムとプロセスをどう改善するか」に焦点を当てる
        """
 
    @staticmethod
    def tech_radar_categories() -> dict:
        """Technology Radar (技術選定の可視化)"""
        return {
            "Adopt (推奨)": [
                "Python 3.12", "pytest", "Ruff", "GitHub Actions",
                "PostgreSQL 16", "Redis 7", "Docker",
            ],
            "Trial (試用中)": [
                "FastAPI", "Pydantic v2", "uv (package manager)",
                "Playwright (E2E)", "OpenTelemetry",
            ],
            "Assess (評価中)": [
                "Rust (パフォーマンスクリティカル部分)",
                "Deno", "Bun", "Effect-TS",
            ],
            "Hold (非推奨)": [
                "Django (新規プロジェクト)", "unittest (pytest推奨)",
                "Travis CI (GitHub Actions推奨)", "Python 3.9以前",
            ],
        }
 
    @staticmethod
    def definition_of_done() -> list[str]:
        """Definition of Done (完了の定義)"""
        return [
            "[ ] コードがリファクタリングされている（ボーイスカウトルール適用）",
            "[ ] ユニットテストが書かれている（カバレッジ ≥ 80%）",
            "[ ] 型ヒントが追加されている（MyPy strict パス）",
            "[ ] Lint/Format チェックをパスしている",
            "[ ] コードレビューが完了している（1名以上の承認）",
            "[ ] 統合テストが更新されている（必要な場合）",
            "[ ] ドキュメントが更新されている（API変更の場合）",
            "[ ] セキュリティチェックをパスしている",
            "[ ] パフォーマンスへの影響が確認されている",
            "[ ] 新しい技術的負債がバックログに記録されている（発生した場合）",
        ]