"""技術的負債の深刻度分類"""
from enum import IntEnum
from dataclasses import dataclass, field
from typing import Optional
from datetime import datetime, timedelta
 
 
class DebtSeverity(IntEnum):
    """負債の深刻度レベル"""
    TRIVIAL = 1    # 見た目の問題: 命名、フォーマット
    MINOR = 2      # 小さな設計問題: 重複コード、長いメソッド
    MAJOR = 3      # 重要な設計問題: 循環依存、レイヤー違反
    CRITICAL = 4   # 深刻な構造問題: セキュリティ脆弱性、データ不整合
    BLOCKER = 5    # 致命的: 本番障害リスク、スケーラビリティ限界
 
 
class DebtCategory(str):
    CODE = "code"
    ARCHITECTURE = "architecture"
    TEST = "test"
    INFRASTRUCTURE = "infrastructure"
    PROCESS = "process"
 
 
@dataclass
class TechnicalDebtItem:
    """技術的負債の個別アイテム"""
    id: str
    title: str
    description: str
    category: str
    severity: DebtSeverity
 
    # 影響度メトリクス
    impact_score: int          # ビジネスへの影響 (1-5)
    fix_effort_days: float     # 修正にかかる推定日数
    affected_frequency: int    # 影響を受ける頻度 (1-5, 5=毎日)
    risk_score: int            # リスク (1-5)
 
    # 追跡情報
    discovered_date: datetime = field(default_factory=datetime.now)
    reporter: str = ""
    assigned_to: Optional[str] = None
    target_sprint: Optional[str] = None
    status: str = "open"  # open, in_progress, resolved, wont_fix
 
    # 関連ファイル
    affected_files: list[str] = field(default_factory=list)
    related_tickets: list[str] = field(default_factory=list)
 
    @property
    def priority_score(self) -> float:
        """優先度スコア: 高いほど先に返済すべき
 
        計算式: (impact * frequency * risk) / effort
        - 影響が大きく、頻繁に発生し、リスクが高い負債を優先
        - 修正工数が小さい負債を優先 (Quick Win)
        """
        return (
            self.impact_score * self.affected_frequency * self.risk_score
        ) / max(self.fix_effort_days, 0.5)
 
    @property
    def annual_interest_cost(self) -> float:
        """年間利子コスト（概算、人日単位）
 
        利子 = 影響度 × 頻度 × 0.1日（1回あたりのオーバーヘッド）× 250営業日/年
        """
        overhead_per_occurrence = 0.1 * self.impact_score
        occurrences_per_year = self.affected_frequency * 50  # 週5日 × 50週
        return overhead_per_occurrence * occurrences_per_year
 
    @property
    def roi(self) -> float:
        """投資対効果: 年間利子削減額 / 修正工数
 
        ROI > 1: 1年以内に投資回収
        ROI > 3: 四半期以内に回収（高優先）
        """
        return self.annual_interest_cost / max(self.fix_effort_days, 0.5)
 
    @property
    def debt_age_days(self) -> int:
        """負債の経過日数"""
        return (datetime.now() - self.discovered_date).days
 
    def __str__(self) -> str:
        status_icon = {
            "open": "[OPEN]", "in_progress": "[WIP]",
            "resolved": "[DONE]", "wont_fix": "[SKIP]"
        }
        return (
            f"{status_icon.get(self.status, '[?]')} "
            f"[{self.severity.name}] {self.title} "
            f"(Priority: {self.priority_score:.1f}, ROI: {self.roi:.1f})"
        )

"""技術的負債メトリクス収集フレームワーク"""
import subprocess
import json
from pathlib import Path
from dataclasses import dataclass
from datetime import datetime
 
 
@dataclass
class DebtMetrics:
    """収集された負債メトリクス"""
    # コード品質
    avg_complexity: float = 0.0
    max_complexity: float = 0.0
    high_complexity_count: int = 0       # CC > 10 の関数数
    very_high_complexity_count: int = 0  # CC > 20 の関数数
 
    # 重複
    duplication_percentage: float = 0.0
    duplicate_blocks: int = 0
 
    # 依存関係
    outdated_dependencies: int = 0
    critical_updates: int = 0            # メジャーバージョン遅れ
    known_vulnerabilities: int = 0
 
    # テスト
    test_coverage: float = 0.0
    flaky_test_count: int = 0
    test_execution_time_sec: float = 0.0
 
    # 保守性
    todo_count: int = 0                  # TODO/FIXME/HACK
    large_files_count: int = 0           # 500行超のファイル数
    large_functions_count: int = 0       # 50行超の関数数
 
    # 全体スコア
    timestamp: str = ""
 
    @property
    def debt_score(self) -> int:
        """技術的負債スコア (0-100, 低いほど健全)
 
        各カテゴリのスコアを重み付きで集計:
        - コード品質: 30%
        - テスト: 25%
        - 依存関係: 20%
        - 保守性: 25%
        """
        # コード品質スコア (0-30)
        complexity_score = min(self.avg_complexity / 15 * 30, 30)
 
        # テストスコア (0-25)
        coverage_penalty = max(0, (80 - self.test_coverage)) / 80 * 25
 
        # 依存関係スコア (0-20)
        dep_score = min((self.outdated_dependencies + self.known_vulnerabilities * 3) / 20 * 20, 20)
 
        # 保守性スコア (0-25)
        maintainability = min(
            (self.todo_count / 50 + self.large_files_count / 10 +
             self.duplication_percentage / 10) / 3 * 25, 25
        )
 
        return int(complexity_score + coverage_penalty + dep_score + maintainability)
 
    @property
    def health_status(self) -> str:
        score = self.debt_score
        if score < 25:
            return "HEALTHY"
        elif score < 50:
            return "CAUTION"
        elif score < 75:
            return "WARNING"
        else:
            return "CRITICAL"
 
 
def collect_debt_metrics(repo_path: str) -> DebtMetrics:
    """リポジトリの技術的負債指標を収集"""
    metrics = DebtMetrics(timestamp=datetime.now().isoformat())
    repo = Path(repo_path)
 
    # 1. コード複雑度 (Cyclomatic Complexity) -- radon
    try:
        result = subprocess.run(
            ["radon", "cc", str(repo / "src"), "-a", "-j"],
            capture_output=True, text=True, timeout=120
        )
        if result.returncode == 0:
            cc_data = json.loads(result.stdout)
            # radon の出力形式に応じてパース
            complexities = []
            for filepath, functions in cc_data.items():
                if isinstance(functions, list):
                    for func in functions:
                        complexities.append(func.get("complexity", 0))
 
            if complexities:
                metrics.avg_complexity = sum(complexities) / len(complexities)
                metrics.max_complexity = max(complexities)
                metrics.high_complexity_count = sum(1 for c in complexities if c > 10)
                metrics.very_high_complexity_count = sum(1 for c in complexities if c > 20)
    except (subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError):
        pass
 
    # 2. コード重複率 -- jscpd
    try:
        result = subprocess.run(
            ["jscpd", str(repo / "src"), "--reporters", "json",
             "--min-lines", "5", "--output", "/tmp/jscpd-report"],
            capture_output=True, text=True, timeout=120
        )
        report_path = Path("/tmp/jscpd-report/jscpd-report.json")
        if report_path.exists():
            report = json.loads(report_path.read_text())
            stats = report.get("statistics", {}).get("total", {})
            metrics.duplication_percentage = stats.get("percentage", 0)
            metrics.duplicate_blocks = stats.get("duplicates", 0)
    except (subprocess.TimeoutExpired, FileNotFoundError):
        pass
 
    # 3. 依存関係の古さ -- pip
    try:
        result = subprocess.run(
            ["pip", "list", "--outdated", "--format=json"],
            capture_output=True, text=True, timeout=60
        )
        if result.returncode == 0:
            outdated = json.loads(result.stdout)
            metrics.outdated_dependencies = len(outdated)
            metrics.critical_updates = sum(
                1 for d in outdated
                if _is_major_version_behind(d.get("version", ""), d.get("latest_version", ""))
            )
    except (subprocess.TimeoutExpired, FileNotFoundError):
        pass
 
    # 4. セキュリティ脆弱性 -- safety
    try:
        result = subprocess.run(
            ["safety", "check", "--json"],
            capture_output=True, text=True, timeout=60
        )
        if result.stdout:
            vulns = json.loads(result.stdout)
            metrics.known_vulnerabilities = len(vulns) if isinstance(vulns, list) else 0
    except (subprocess.TimeoutExpired, FileNotFoundError):
        pass
 
    # 5. TODO/FIXME/HACK の数
    try:
        result = subprocess.run(
            ["grep", "-r", "-c", "-E", "TODO|FIXME|HACK|XXX", str(repo / "src")],
            capture_output=True, text=True, timeout=30
        )
        metrics.todo_count = sum(
            int(line.split(":")[-1])
            for line in result.stdout.strip().split("\n")
            if line and ":" in line
        )
    except (subprocess.TimeoutExpired, ValueError):
        pass
 
    # 6. 大きなファイル/関数の検出
    try:
        for py_file in (repo / "src").rglob("*.py"):
            lines = py_file.read_text().split("\n")
            if len(lines) > 500:
                metrics.large_files_count += 1
    except (FileNotFoundError, PermissionError):
        pass
 
    return metrics
 
 
def _is_major_version_behind(current: str, latest: str) -> bool:
    """メジャーバージョンが異なるかチェック"""
    try:
        current_major = int(current.split(".")[0])
        latest_major = int(latest.split(".")[0])
        return latest_major > current_major
    except (ValueError, IndexError):
        return False

"""技術的負債ダッシュボード"""
 
def print_debt_dashboard(metrics: DebtMetrics) -> None:
    """テキストベースの負債ダッシュボードを表示"""
 
    def status_icon(value: float, good: float, warn: float, higher_is_better: bool = False) -> str:
        if higher_is_better:
            if value >= good: return "[OK]"
            elif value >= warn: return "[WARN]"
            else: return "[CRIT]"
        else:
            if value <= good: return "[OK]"
            elif value <= warn: return "[WARN]"
            else: return "[CRIT]"
 
    width = 64
    print("=" * width)
    print("  技術的負債ダッシュボード".center(width))
    print(f"  {metrics.timestamp}".center(width))
    print("=" * width)
 
    print("\n  [コード品質]")
    print(f"    平均複雑度 (CC):     {metrics.avg_complexity:6.1f}  "
          f"{status_icon(metrics.avg_complexity, 5, 10)}")
    print(f"    最大複雑度 (CC):     {metrics.max_complexity:6.1f}  "
          f"{status_icon(metrics.max_complexity, 15, 25)}")
    print(f"    高複雑度関数 (>10):  {metrics.high_complexity_count:6d}  件")
    print(f"    超高複雑度 (>20):    {metrics.very_high_complexity_count:6d}  件")
 
    print("\n  [コード重複]")
    print(f"    重複率:              {metrics.duplication_percentage:6.1f}% "
          f"{status_icon(metrics.duplication_percentage, 3, 10)}")
    print(f"    重複ブロック数:      {metrics.duplicate_blocks:6d}  件")
 
    print("\n  [テスト]")
    print(f"    カバレッジ:          {metrics.test_coverage:6.1f}% "
          f"{status_icon(metrics.test_coverage, 80, 60, higher_is_better=True)}")
    print(f"    Flaky テスト:        {metrics.flaky_test_count:6d}  件")
    print(f"    実行時間:            {metrics.test_execution_time_sec:6.1f}  秒")
 
    print("\n  [依存関係]")
    print(f"    古い依存:            {metrics.outdated_dependencies:6d}  件")
    print(f"    メジャー遅れ:        {metrics.critical_updates:6d}  件")
    print(f"    既知脆弱性:          {metrics.known_vulnerabilities:6d}  件 "
          f"{status_icon(metrics.known_vulnerabilities, 0, 3)}")
 
    print("\n  [保守性]")
    print(f"    TODO/FIXME/HACK:     {metrics.todo_count:6d}  件")
    print(f"    巨大ファイル (>500L):{metrics.large_files_count:6d}  件")
 
    print("\n" + "-" * width)
    score = metrics.debt_score
    health = metrics.health_status
    bar_length = 40
    filled = int(score / 100 * bar_length)
    bar = "#" * filled + "-" * (bar_length - filled)
 
    print(f"  負債スコア: [{bar}] {score}/100")
    print(f"  健全性:     {health}")
 
    if health == "HEALTHY":
        print("  --> 健全な状態。現在の品質維持プラクティスを継続")
    elif health == "CAUTION":
        print("  --> 要注意。計画的な返済を開始し、悪化を防止")
    elif health == "WARNING":
        print("  --> 警告。開発速度に影響が出始めている。早急な対策を推奨")
    else:
        print("  --> 危険。開発速度に深刻な影響。負債スプリントの実施を推奨")
 
    print("=" * width)

"""ホットスポット分析: 変更頻度 x 複雑度でリファクタリング優先箇所を特定"""
import subprocess
import json
from collections import Counter
from dataclasses import dataclass
from pathlib import Path
 
 
@dataclass
class Hotspot:
    """変更頻度と複雑度のホットスポット"""
    filepath: str
    change_count: int       # git log での変更回数
    complexity: float       # 平均循環的複雑度
    lines_of_code: int      # 行数
    bug_fix_count: int      # バグ修正での変更回数
 
    @property
    def hotspot_score(self) -> float:
        """ホットスポットスコア
 
        高い変更頻度 × 高い複雑度 = 高リスク
        バグ修正が多いファイルはさらに重み付け
        """
        bug_weight = 1.0 + (self.bug_fix_count / max(self.change_count, 1))
        return self.change_count * self.complexity * bug_weight
 
    @property
    def risk_level(self) -> str:
        score = self.hotspot_score
        if score > 500: return "CRITICAL"
        elif score > 200: return "HIGH"
        elif score > 100: return "MEDIUM"
        else: return "LOW"
 
 
def analyze_hotspots(
    repo_path: str,
    since: str = "6 months ago",
    top_n: int = 20
) -> list[Hotspot]:
    """Git履歴と複雑度からホットスポットを分析"""
 
    # 1. 変更頻度の収集 (git log)
    result = subprocess.run(
        ["git", "log", "--since", since, "--name-only",
         "--pretty=format:", "--diff-filter=M"],
        capture_output=True, text=True, cwd=repo_path
    )
    file_changes = Counter(
        line.strip() for line in result.stdout.split("\n")
        if line.strip() and line.strip().endswith(".py")
    )
 
    # 2. バグ修正での変更回数
    result = subprocess.run(
        ["git", "log", "--since", since, "--name-only",
         "--pretty=format:", "--grep=fix", "--grep=bug", "-i"],
        capture_output=True, text=True, cwd=repo_path
    )
    bug_changes = Counter(
        line.strip() for line in result.stdout.split("\n")
        if line.strip() and line.strip().endswith(".py")
    )
 
    # 3. 複雑度の収集 (radon)
    hotspots = []
    for filepath, change_count in file_changes.most_common(top_n * 2):
        full_path = Path(repo_path) / filepath
        if not full_path.exists():
            continue
 
        try:
            result = subprocess.run(
                ["radon", "cc", str(full_path), "-a", "-j"],
                capture_output=True, text=True, timeout=10
            )
            cc_data = json.loads(result.stdout)
            complexities = []
            for fpath, funcs in cc_data.items():
                if isinstance(funcs, list):
                    complexities.extend(f.get("complexity", 0) for f in funcs)
 
            avg_cc = sum(complexities) / len(complexities) if complexities else 1.0
            loc = len(full_path.read_text().split("\n"))
 
            hotspots.append(Hotspot(
                filepath=filepath,
                change_count=change_count,
                complexity=avg_cc,
                lines_of_code=loc,
                bug_fix_count=bug_changes.get(filepath, 0),
            ))
        except (subprocess.TimeoutExpired, json.JSONDecodeError, FileNotFoundError):
            continue
 
    # スコア順にソート
    hotspots.sort(key=lambda h: h.hotspot_score, reverse=True)
    return hotspots[:top_n]
 
 
def print_hotspot_report(hotspots: list[Hotspot]) -> None:
    """ホットスポットレポートを表示"""
    print("=" * 80)
    print("  ホットスポット分析レポート")
    print("=" * 80)
    print(f"  {'Rank':<5} {'File':<35} {'Changes':<8} {'CC':<6} {'Bugs':<5} {'Risk':<10}")
    print("-" * 80)
 
    for i, h in enumerate(hotspots, 1):
        short_path = h.filepath if len(h.filepath) < 33 else "..." + h.filepath[-30:]
        print(
            f"  {i:<5} {short_path:<35} {h.change_count:<8} "
            f"{h.complexity:<6.1f} {h.bug_fix_count:<5} {h.risk_level:<10}"
        )
 
    print("-" * 80)
    critical = sum(1 for h in hotspots if h.risk_level == "CRITICAL")
    high = sum(1 for h in hotspots if h.risk_level == "HIGH")
    print(f"  CRITICAL: {critical} ファイル  /  HIGH: {high} ファイル")
    print("=" * 80)

"""技術的負債のビジネスコスト算出"""
from dataclasses import dataclass
 
 
@dataclass
class DebtCostEstimation:
    """技術的負債のコスト見積もり"""
 
    # チーム情報
    team_size: int = 8
    developer_hourly_rate: int = 5000  # 円/時間
    working_hours_per_week: int = 40
    working_weeks_per_year: int = 50
 
    # 負債によるオーバーヘッド (時間/週/人)
    bug_fix_overhead: float = 1.0        # バグ修正の追加時間
    feature_dev_overhead: float = 1.5    # 機能追加の複雑性コスト
    onboarding_overhead: float = 0.5     # オンボーディングコスト（チーム平均）
    manual_process_overhead: float = 0.75 # 手動テスト・デプロイ
    incident_overhead: float = 0.25      # インシデント対応の追加時間
    context_switching: float = 0.5       # 技術的問題によるコンテキストスイッチ
 
    @property
    def weekly_overhead_per_person(self) -> float:
        """1人あたり週間オーバーヘッド（時間）"""
        return (
            self.bug_fix_overhead +
            self.feature_dev_overhead +
            self.onboarding_overhead +
            self.manual_process_overhead +
            self.incident_overhead +
            self.context_switching
        )
 
    @property
    def weekly_overhead_total(self) -> float:
        """チーム全体の週間オーバーヘッド（時間）"""
        return self.weekly_overhead_per_person * self.team_size
 
    @property
    def productivity_loss_percentage(self) -> float:
        """生産性損失率（%）"""
        return (self.weekly_overhead_per_person / self.working_hours_per_week) * 100
 
    @property
    def annual_cost(self) -> int:
        """年間コスト（円）"""
        return int(
            self.weekly_overhead_total *
            self.developer_hourly_rate *
            self.working_weeks_per_year
        )
 
    def print_report(self) -> None:
        """コストレポートを出力"""
        print("=" * 60)
        print("  技術的負債コストレポート")
        print("=" * 60)
        print(f"\n  チーム構成: {self.team_size}名")
        print(f"  時間単価:  {self.developer_hourly_rate:,}円/時間")
 
        print(f"\n  --- 週間オーバーヘッド (1人あたり) ---")
        items = [
            ("バグ修正の追加時間", self.bug_fix_overhead),
            ("機能追加の複雑性コスト", self.feature_dev_overhead),
            ("オンボーディングコスト", self.onboarding_overhead),
            ("手動プロセス", self.manual_process_overhead),
            ("インシデント対応", self.incident_overhead),
            ("コンテキストスイッチ", self.context_switching),
        ]
        for name, hours in items:
            print(f"    {name:<24s} {hours:5.2f} 時間/週")
 
        print(f"    {'─' * 36}")
        print(f"    {'合計':<24s} {self.weekly_overhead_per_person:5.2f} 時間/週/人")
 
        print(f"\n  --- 影響サマリ ---")
        print(f"    チーム週間オーバーヘッド: {self.weekly_overhead_total:,.0f} 時間/週")
        print(f"    生産性損失率:            {self.productivity_loss_percentage:.1f}%")
        print(f"    週間コスト:              {int(self.weekly_overhead_total * self.developer_hourly_rate):>12,} 円")
        print(f"    月間コスト:              {int(self.weekly_overhead_total * self.developer_hourly_rate * 4):>12,} 円")
        print(f"    年間コスト:              {self.annual_cost:>12,} 円")
 
        print(f"\n  --- 投資対効果 (例) ---")
        investment = self.annual_cost * 0.3  # 年間コストの30%を投資
        savings = self.annual_cost * 0.5     # 50%の改善を見込む
        print(f"    投資額 (30%の工数投入):  {int(investment):>12,} 円")
        print(f"    期待削減額 (50%改善):    {int(savings):>12,} 円")
        print(f"    純利益:                  {int(savings - investment):>12,} 円")
        print(f"    ROI:                     {(savings - investment) / investment * 100:>11.0f}%")
        print("=" * 60)
 
 
# 使用例
cost = DebtCostEstimation(
    team_size=8,
    developer_hourly_rate=5000,
    bug_fix_overhead=1.0,
    feature_dev_overhead=1.5,
    onboarding_overhead=0.5,
    manual_process_overhead=0.75,
    incident_overhead=0.25,
    context_switching=0.5,
)
cost.print_report()
 
# 出力例:
# チーム週間オーバーヘッド: 36.0 時間/週
# 生産性損失率:            11.3%
# 年間コスト:          9,000,000 円
# ROI:                          67%

"""ボーイスカウトルール: コードを見つけた時より少しきれいにして去る"""
 
# === 例1: 変数名の改善 ===
 
# Before (見つけた時の状態)
def calc(d, r):
    return d * r * 0.01
 
# After (少しきれいにして去る)
def calculate_discount(price: float, rate_percent: float) -> float:
    """割引額を計算する"""
    return price * rate_percent * 0.01
 
 
# === 例2: マジックナンバーの除去 ===
 
# Before
if user.login_attempts > 5:
    lock_account(user)
 
# After
MAX_LOGIN_ATTEMPTS = 5
 
if user.login_attempts > MAX_LOGIN_ATTEMPTS:
    lock_account(user)
 
 
# === 例3: 不要なコメントの削除と型ヒント追加 ===
 
# Before
# ユーザーを取得する
def get_user(id):
    # DBから取得
    user = db.query(User).filter(User.id == id).first()
    return user  # ユーザーを返す
 
# After
def get_user(user_id: int) -> User | None:
    return db.query(User).filter(User.id == user_id).first()

"""20%ルール: 各スプリントの20%を技術的負債返済に充てる"""
 
@dataclass
class SprintCapacity:
    """スプリントのキャパシティ管理"""
    total_story_points: int
    team_size: int
    sprint_days: int = 10  # 2週間スプリント
 
    @property
    def feature_capacity(self) -> int:
        """新機能に使えるポイント (80%)"""
        return int(self.total_story_points * 0.80)
 
    @property
    def debt_capacity(self) -> int:
        """負債返済に使えるポイント (20%)"""
        return int(self.total_story_points * 0.20)
 
    def plan_sprint(
        self,
        feature_backlog: list[dict],
        debt_backlog: list[TechnicalDebtItem]
    ) -> dict:
        """スプリント計画"""
        # 新機能を80%枠内で選択
        selected_features = []
        remaining_feature_points = self.feature_capacity
        for feature in feature_backlog:
            if feature["points"] <= remaining_feature_points:
                selected_features.append(feature)
                remaining_feature_points -= feature["points"]
 
        # 負債を20%枠内で選択（優先度順）
        selected_debt = []
        remaining_debt_points = self.debt_capacity
        sorted_debt = sorted(debt_backlog, key=lambda d: d.priority_score, reverse=True)
        for debt in sorted_debt:
            estimated_points = int(debt.fix_effort_days * 2)  # 1日 ≈ 2SP
            if estimated_points <= remaining_debt_points:
                selected_debt.append(debt)
                remaining_debt_points -= estimated_points
 
        return {
            "features": selected_features,
            "debt_items": selected_debt,
            "feature_points_used": self.feature_capacity - remaining_feature_points,
            "debt_points_used": self.debt_capacity - remaining_debt_points,
        }

"""技術的負債スプリント: 四半期に1回の集中返済"""
 
@dataclass
class DebtSprint:
    """技術的負債スプリントの計画と実行"""
    quarter: str              # "2024-Q2"
    duration_days: int = 10   # 2週間
    team_size: int = 8
 
    def plan(self, debt_backlog: list[TechnicalDebtItem]) -> dict:
        """負債スプリントの計画
 
        選定基準:
        1. ROI が最も高い負債を優先
        2. 相互依存する負債をグループ化
        3. チームのスキルセットと負債の種類をマッチング
        """
        # ROI 順にソート
        sorted_debt = sorted(debt_backlog, key=lambda d: d.roi, reverse=True)
 
        # キャパシティ計算 (チーム × 日数)
        total_capacity_days = self.team_size * self.duration_days
 
        selected = []
        remaining_capacity = total_capacity_days
 
        for debt in sorted_debt:
            if debt.fix_effort_days <= remaining_capacity:
                selected.append(debt)
                remaining_capacity -= debt.fix_effort_days
 
        # 期待効果の算出
        total_annual_savings = sum(d.annual_interest_cost for d in selected)
        total_investment = sum(d.fix_effort_days for d in selected)
 
        return {
            "quarter": self.quarter,
            "selected_items": selected,
            "total_investment_days": total_investment,
            "total_annual_savings_days": total_annual_savings,
            "overall_roi": total_annual_savings / max(total_investment, 1),
            "remaining_capacity_days": remaining_capacity,
        }
 
    def execute_checklist(self) -> list[str]:
        """負債スプリント実施チェックリスト"""
        return [
            "[ ] Sprint Goal を明確に定義（測定可能な指標で）",
            "[ ] Before メトリクスを収集（複雑度、カバレッジ、重複率）",
            "[ ] 各負債アイテムに担当者をアサイン",
            "[ ] 各変更に対するテストを先に書く",
            "[ ] 小さなPRに分割（1PR = 1改善）",
            "[ ] デイリースタンドアップで進捗共有",
            "[ ] After メトリクスを収集",
            "[ ] Before/After の比較レポートを作成",
            "[ ] 振り返り（レトロスペクティブ）を実施",
            "[ ] 残った負債を次回に繰り越し",
        ]

"""技術的負債バックログの管理"""
from datetime import datetime
from typing import Optional
 
 
class TechnicalDebtBacklog:
    """技術的負債バックログの管理クラス"""
 
    def __init__(self):
        self._items: list[TechnicalDebtItem] = []
 
    def add(self, item: TechnicalDebtItem) -> None:
        """負債アイテムを追加"""
        self._items.append(item)
 
    def get_by_priority(self, top_n: int = 10) -> list[TechnicalDebtItem]:
        """優先度順に取得"""
        open_items = [i for i in self._items if i.status == "open"]
        return sorted(open_items, key=lambda i: i.priority_score, reverse=True)[:top_n]
 
    def get_by_roi(self, top_n: int = 10) -> list[TechnicalDebtItem]:
        """ROI順に取得（Quick Win 発見用）"""
        open_items = [i for i in self._items if i.status == "open"]
        return sorted(open_items, key=lambda i: i.roi, reverse=True)[:top_n]
 
    def get_quick_wins(self, max_effort_days: float = 1.0) -> list[TechnicalDebtItem]:
        """Quick Win: 少ない工数で高い効果が得られる負債"""
        return [
            i for i in self._items
            if i.status == "open" and i.fix_effort_days <= max_effort_days
        ]
 
    def get_stale_items(self, days: int = 90) -> list[TechnicalDebtItem]:
        """長期間放置されている負債"""
        return [
            i for i in self._items
            if i.status == "open" and i.debt_age_days > days
        ]
 
    def summary(self) -> dict:
        """バックログのサマリ"""
        open_items = [i for i in self._items if i.status == "open"]
        resolved = [i for i in self._items if i.status == "resolved"]
 
        total_effort = sum(i.fix_effort_days for i in open_items)
        total_interest = sum(i.annual_interest_cost for i in open_items)
 
        by_category = {}
        for item in open_items:
            cat = item.category
            if cat not in by_category:
                by_category[cat] = {"count": 0, "effort": 0.0}
            by_category[cat]["count"] += 1
            by_category[cat]["effort"] += item.fix_effort_days
 
        by_severity = {}
        for item in open_items:
            sev = item.severity.name
            by_severity[sev] = by_severity.get(sev, 0) + 1
 
        return {
            "total_open": len(open_items),
            "total_resolved": len(resolved),
            "total_effort_days": total_effort,
            "total_annual_interest_days": total_interest,
            "by_category": by_category,
            "by_severity": by_severity,
            "avg_age_days": (
                sum(i.debt_age_days for i in open_items) / len(open_items)
                if open_items else 0
            ),
        }
 
    def print_summary(self) -> None:
        """バックログサマリを表示"""
        s = self.summary()
        print("=" * 50)
        print("  技術的負債バックログ サマリ")
        print("=" * 50)
        print(f"  未対応: {s['total_open']} 件  /  解決済: {s['total_resolved']} 件")
        print(f"  合計修正工数: {s['total_effort_days']:.0f} 人日")
        print(f"  年間利子: {s['total_annual_interest_days']:.0f} 人日")
        print(f"  平均経過日数: {s['avg_age_days']:.0f} 日")
 
        print(f"\n  [カテゴリ別]")
        for cat, data in s["by_category"].items():
            print(f"    {cat:<20s} {data['count']:3d} 件  ({data['effort']:.0f} 人日)")
 
        print(f"\n  [深刻度別]")
        for sev, count in sorted(s["by_severity"].items()):
            print(f"    {sev:<12s} {count:3d} 件")
        print("=" * 50)

# .github/workflows/debt-tracking.yml
name: Technical Debt Tracking
 
on:
  schedule:
    - cron: '0 9 * * 1'  # 毎週月曜9時
  workflow_dispatch:
 
jobs:
  track-debt:
    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 radon coverage safety
          npm install -g jscpd
 
      - name: Collect metrics
        run: |
          python scripts/collect_debt_metrics.py \
            --output debt-metrics.json
 
      - name: Check thresholds
        run: |
          python scripts/check_debt_thresholds.py \
            --input debt-metrics.json \
            --max-complexity 8 \
            --min-coverage 80 \
            --max-duplication 5
 
      - name: Update trend data
        run: |
          python scripts/update_debt_trend.py \
            --input debt-metrics.json \
            --trend-file debt-trend.json
 
      - name: Post to Slack (if degraded)
        if: failure()
        uses: slackapi/slack-github-action@v1
        with:
          payload: |
            {
              "text": "技術的負債アラート: 品質メトリクスが閾値を超えました",
              "blocks": [
                {
                  "type": "section",
                  "text": {
                    "type": "mrkdwn",
                    "text": "詳細: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
                  }
                }
              ]
            }
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

# .github/workflows/debt-check-pr.yml
name: Debt Check on PR
 
on:
  pull_request:
    branches: [main]
 
jobs:
  debt-impact:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Check complexity of changed files
        run: |
          # 変更されたPythonファイルの複雑度チェック
          git diff --name-only origin/main...HEAD -- '*.py' | while read file; do
            if [ -f "$file" ]; then
              radon cc "$file" -n C -s  # Cランク以上を表示
            fi
          done
 
      - name: Check for new TODOs
        run: |
          # 新しく追加された TODO/FIXME をチェック
          new_todos=$(git diff origin/main...HEAD | grep '^+' | grep -cE 'TODO|FIXME|HACK|XXX' || true)
          if [ "$new_todos" -gt 0 ]; then
            echo "::warning::${new_todos} 件の新しい TODO/FIXME が追加されています"
          fi
 
      - name: Coverage check
        run: |
          pytest --cov=src --cov-report=term --cov-fail-under=80