# エージェント能力レベルの定義
class AgentCapabilityLevel:
    """AIエージェントの能力レベルを段階的に定義"""
 
    LEVELS = {
        "L1_Autocomplete": {
            "era": "2021-2022",
            "description": "行単位のコード補完",
            "example": "GitHub Copilot初期",
            "human_role": "すべての判断を人間が行う",
            "autonomy": 0.1,
        },
        "L2_Task_Completion": {
            "era": "2023-2024",
            "description": "関数・ファイル単位のタスク完了",
            "example": "ChatGPT Code Interpreter, Copilot Chat",
            "human_role": "タスクの分割と指示を人間が行う",
            "autonomy": 0.3,
        },
        "L3_Workflow_Agent": {
            "era": "2024-2025",
            "description": "Issue→PR→テストの一連のワークフロー実行",
            "example": "Claude Code, Devin, SWE-agent",
            "human_role": "要件定義とレビューを人間が行う",
            "autonomy": 0.5,
        },
        "L4_Project_Agent": {
            "era": "2025-2027（予測）",
            "description": "プロジェクト全体の設計・実装・運用",
            "example": "次世代エージェント群",
            "human_role": "ビジョン設定と最終承認を人間が行う",
            "autonomy": 0.7,
        },
        "L5_Collaborative_Agent": {
            "era": "2027-2030（予測）",
            "description": "複数エージェントが協調し大規模システムを構築",
            "example": "マルチエージェントシステム",
            "human_role": "目的定義と倫理的判断を人間が行う",
            "autonomy": 0.85,
        },
    }

# 時代ごとのプログラミングパラダイム比較
 
# === 1960s: 命令型プログラミング ===
# 「どう計算するか」を逐一指示
result = 0
for i in range(len(data)):
    if data[i] > threshold:
        result = result + data[i]
 
# === 1990s: 宣言型プログラミング ===
# 「何が欲しいか」をルールで宣言
# SELECT SUM(value) FROM data WHERE value > :threshold
 
# === 2020s: プロンプト駆動プログラミング ===
# 「自然言語で意図を伝える」
# "dataからthresholdを超える値の合計を求めて"
 
# === 2030s: 意図駆動プログラミング（予測）===
# 「ビジネス目的を伝えるだけ」
# "売上が目標を超えた月の合計を出して、
#  経営会議用のダッシュボードに表示して"

# 2030年のプロジェクト定義ファイル（予測）
# intent.yaml — 意図記述言語
 
project:
  name: "顧客分析ダッシュボード"
  intent: |
    営業チームが顧客の購買パターンを可視化し、
    解約リスクの高い顧客を早期に特定できるシステム
 
  constraints:
    - "既存のPostgreSQLデータベースと接続"
    - "社内SSO認証を使用"
    - "レスポンスタイムは2秒以内"
    - "SOC2準拠のセキュリティ要件"
 
  quality:
    test_coverage: ">= 90%"
    accessibility: "WCAG 2.1 AA"
    performance: "Lighthouse score >= 90"
 
  # AIエージェントがこの意図から以下を自動生成:
  # - 技術選定とアーキテクチャ設計
  # - データモデル設計
  # - API設計とフロントエンド実装
  # - テストスイート
  # - CI/CDパイプライン
  # - 監視・アラート設定

// 2027年のマルチエージェント通信（予測的概念コード）
interface AgentMessage {
  from: AgentId;
  to: AgentId | "broadcast";
  type: "request" | "response" | "event" | "conflict";
  payload: {
    task?: TaskDefinition;
    artifact?: CodeArtifact;
    review?: ReviewResult;
    conflict?: ConflictReport;
  };
  context: SharedContext;
  timestamp: number;
}
 
// Orchestratorがタスクを分配
async function orchestrate(intent: ProjectIntent): Promise<void> {
  const plan = await architectAgent.designSystem(intent);
 
  // 並列実行: フロントエンドとバックエンドの同時開発
  const [frontend, backend] = await Promise.all([
    frontendAgent.implement(plan.uiSpec),
    backendAgent.implement(plan.apiSpec),
  ]);
 
  // 統合テスト
  const testResult = await testAgent.verifyIntegration(frontend, backend);
 
  if (testResult.hasConflicts) {
    // 衝突解決ループ
    await resolveConflicts(testResult.conflicts);
  }
 
  // 人間の承認待ち
  await humanSupervisor.requestApproval({
    plan,
    implementation: { frontend, backend },
    testReport: testResult,
  });
}

# 短期予測: エージェントの能力拡張
 
# 1. リアルタイムコラボレーション
# エージェントが人間と同じエディタ上で同時編集
class RealtimeCollabAgent:
    """人間のエディタカーソルを認識し、
    衝突しないファイルを並行して編集"""
 
    async def collaborate(self, human_cursor_position):
        available_files = self.find_non_conflicting_files(
            human_cursor_position
        )
        for file in available_files:
            await self.edit_autonomously(file)
 
# 2. 自己改善するCI/CD
# テスト失敗時にAIが自動修正を試行
class SelfHealingPipeline:
    """CI失敗を検知し、自動修正PRを作成"""
 
    async def on_pipeline_failure(self, failure):
        diagnosis = await self.analyze_failure(failure)
        fix = await self.generate_fix(diagnosis)
        if await self.verify_fix(fix):
            await self.create_fix_pr(fix)
 
# 3. コンテキスト永続化
# プロジェクトの全履歴をAIが記憶・学習
class ProjectMemory:
    """プロジェクトの設計判断・議論・変更履歴を
    構造化して長期記憶に保持"""
 
    def recall_design_decision(self, component):
        return self.memory.search(
            query=f"Why was {component} designed this way?",
            include_discussions=True,
            include_alternatives_considered=True,
        )

// 中期予測: 意図レベルのインターフェース
 
// 1. 自然言語→デプロイ可能アプリケーション
// 概念的なAPI（実装は2027-2029年に登場予測）
interface IntentToApp {
  // ビジネス意図から完全なアプリケーションを生成
  generateFromIntent(intent: string): Promise<{
    architecture: SystemDesign;
    codebase: Repository;
    infrastructure: InfraConfig;
    tests: TestSuite;
    documentation: DocSet;
    monitoring: MonitoringConfig;
  }>;
}
 
// 2. AIペアプログラミング2.0
// コードの「意味」を理解した上での提案
interface SemanticPairProgramming {
  // 「このコードは何を意図しているか」を理解
  understandIntent(code: string): BusinessIntent;
 
  // ビジネスロジックの矛盾を検出
  detectLogicContradiction(
    codebase: Repository,
    newChange: Diff
  ): Contradiction[];
 
  // リファクタリングの「理由」まで説明
  suggestRefactoring(code: string): {
    suggestion: CodeChange;
    businessReason: string;
    riskAssessment: RiskReport;
  };
}

# AIネイティブ開発の段階的導入を管理するフレームワーク
 
from dataclasses import dataclass, field
from enum import Enum
from datetime import date
 
class AdoptionPhase(Enum):
    EXPLORE = "explore"         # 探索フェーズ
    PILOT = "pilot"             # パイロットフェーズ
    SCALE = "scale"             # スケールフェーズ
    NATIVE = "native"           # ネイティブフェーズ
 
@dataclass
class PhaseDefinition:
    """各フェーズの定義"""
    phase: AdoptionPhase
    duration_months: int
    team_size: int
    ai_autonomy: float  # 0.0-1.0
    key_activities: list[str]
    success_criteria: dict[str, float]
    risks: list[str]
 
@dataclass
class AdoptionRoadmap:
    """AIネイティブ開発導入ロードマップ"""
    organization_name: str
    start_date: date
    phases: list[PhaseDefinition] = field(default_factory=list)
 
    def build_default_roadmap(self) -> None:
        """標準的な4段階ロードマップを構築"""
 
        # Phase 1: 探索（3ヶ月）
        self.phases.append(PhaseDefinition(
            phase=AdoptionPhase.EXPLORE,
            duration_months=3,
            team_size=3,  # パイオニアチーム
            ai_autonomy=0.1,
            key_activities=[
                "AIコーディング支援ツール（Copilot/Claude Code）の個人利用開始",
                "チーム内でプロンプトパターンの知見共有",
                "AI生成コードの品質メトリクス計測開始",
                "セキュリティ・コンプライアンス上の制約事項を整理",
            ],
            success_criteria={
                "tool_adoption_rate": 0.5,  # チームの50%がツール利用
                "developer_satisfaction": 3.5,  # 5段階で3.5以上
                "productivity_gain": 0.1,  # 10%の生産性向上
            },
            risks=[
                "セキュリティポリシー違反（コードの外部送信）",
                "AI依存による基礎スキルの軽視",
            ],
        ))
 
        # Phase 2: パイロット（6ヶ月）
        self.phases.append(PhaseDefinition(
            phase=AdoptionPhase.PILOT,
            duration_months=6,
            team_size=10,
            ai_autonomy=0.3,
            key_activities=[
                "CI/CDにAIレビュー・テスト生成を統合",
                "定型ワークフローのエージェント自動化",
                "プロンプトテンプレートの標準化",
                "品質ゲートの自動化（lint, type check, security scan）",
                "AIペアプログラミングのガイドライン策定",
            ],
            success_criteria={
                "ci_ai_coverage": 0.7,  # CI/CDの70%にAIゲート
                "test_generation_ratio": 0.3,  # テストの30%をAIが生成
                "review_time_reduction": 0.3,  # レビュー時間30%削減
            },
            risks=[
                "AIが生成する低品質コードの蓄積",
                "チームメンバー間のスキル格差拡大",
            ],
        ))
 
        # Phase 3: スケール（6ヶ月）
        self.phases.append(PhaseDefinition(
            phase=AdoptionPhase.SCALE,
            duration_months=6,
            team_size=30,  # 複数チーム
            ai_autonomy=0.5,
            key_activities=[
                "全チームへのAIツール展開",
                "マルチエージェントワークフローの導入",
                "AI品質ダッシュボードの全社展開",
                "エージェントのカスタムプロンプト/ルール整備",
                "インシデント対応でのAI活用",
            ],
            success_criteria={
                "org_adoption_rate": 0.8,  # 組織の80%が利用
                "productivity_gain": 0.3,  # 30%の生産性向上
                "defect_reduction": 0.2,  # 欠陥20%削減
            },
            risks=[
                "組織文化との摩擦",
                "ガバナンスの複雑化",
            ],
        ))
 
        # Phase 4: ネイティブ（継続的）
        self.phases.append(PhaseDefinition(
            phase=AdoptionPhase.NATIVE,
            duration_months=0,  # 継続的
            team_size=0,  # 全組織
            ai_autonomy=0.7,
            key_activities=[
                "AIエージェントをチームメンバーとして正式に位置づけ",
                "意図駆動開発プロセスの確立",
                "AIが主導するプロジェクト計画・見積もり",
                "自律的な品質改善ループの運用",
                "次世代エージェント技術の継続的な評価・導入",
            ],
            success_criteria={
                "ai_team_ratio": 0.5,  # チームの50%がAIエージェント
                "intent_to_deploy": 0.6,  # 60%のタスクが意図→デプロイ
                "human_focus_ratio": 0.8,  # 人間の80%が設計・検証に集中
            },
            risks=[
                "スキル空洞化の顕在化",
                "AI障害時の事業継続性",
            ],
        ))
 
    def estimate_timeline(self) -> str:
        """全体のタイムライン見積もりを生成"""
        total_months = sum(p.duration_months for p in self.phases if p.duration_months > 0)
        lines = [
            f"=== {self.organization_name} AIネイティブ開発ロードマップ ===\n",
            f"開始日: {self.start_date}",
            f"Phase 1-3 完了予定: {total_months}ヶ月後",
            f"Phase 4 以降: 継続的改善\n",
        ]
 
        current = self.start_date
        for phase in self.phases:
            lines.append(f"--- {phase.phase.value.upper()} ---")
            lines.append(f"  期間: {phase.duration_months}ヶ月" if phase.duration_months else "  期間: 継続的")
            lines.append(f"  対象: {phase.team_size}名" if phase.team_size else "  対象: 全組織")
            lines.append(f"  AI自律度: {phase.ai_autonomy:.0%}")
            lines.append(f"  主要活動: {len(phase.key_activities)}項目")
            lines.append("")
 
        return "\n".join(lines)

# AIネイティブ開発のROI計測フレームワーク
 
from dataclasses import dataclass
 
@dataclass
class AIDevelopmentROI:
    """AI開発投資の対効果を計測"""
 
    # コスト項目
    ai_tool_cost_monthly: float  # AIツールライセンス費（月額）
    training_cost: float  # トレーニング費用（一時）
    infrastructure_cost_monthly: float  # 追加インフラ費（月額）
    productivity_loss_during_adoption: float  # 導入期間の生産性低下
 
    # 効果項目
    developer_hourly_rate: float  # 開発者の時間単価
    team_size: int  # チーム人数
    hours_saved_per_dev_weekly: float  # 開発者あたり週間節約時間
    defect_reduction_rate: float  # 欠陥削減率
    avg_defect_fix_cost: float  # 欠陥修正の平均コスト
    monthly_defects_before: int  # 導入前の月間欠陥数
 
    def monthly_cost(self) -> float:
        """月間コスト"""
        return self.ai_tool_cost_monthly + self.infrastructure_cost_monthly
 
    def monthly_savings(self) -> float:
        """月間節約額"""
        # 時間節約による効果
        time_savings = (
            self.developer_hourly_rate
            * self.hours_saved_per_dev_weekly
            * 4.3  # 週→月変換
            * self.team_size
        )
 
        # 欠陥削減による効果
        defect_savings = (
            self.monthly_defects_before
            * self.defect_reduction_rate
            * self.avg_defect_fix_cost
        )
 
        return time_savings + defect_savings
 
    def monthly_roi(self) -> float:
        """月間ROI（%）"""
        cost = self.monthly_cost()
        if cost == 0:
            return 0
        return ((self.monthly_savings() - cost) / cost) * 100
 
    def payback_months(self) -> float:
        """投資回収期間（月）"""
        net_monthly = self.monthly_savings() - self.monthly_cost()
        if net_monthly <= 0:
            return float("inf")
        initial_investment = self.training_cost + self.productivity_loss_during_adoption
        return initial_investment / net_monthly
 
    def generate_report(self) -> str:
        """ROIレポート生成"""
        return f"""
=== AIネイティブ開発 ROI分析 ===
 
【コスト】
  ツール費: ¥{self.monthly_cost():,.0f}/月
  初期投資: ¥{self.training_cost + self.productivity_loss_during_adoption:,.0f}
 
【効果】
  月間節約額: ¥{self.monthly_savings():,.0f}
  月間純利益: ¥{self.monthly_savings() - self.monthly_cost():,.0f}
 
【ROI指標】
  月間ROI: {self.monthly_roi():.0f}%
  投資回収: {self.payback_months():.1f}ヶ月
  年間節約: ¥{(self.monthly_savings() - self.monthly_cost()) * 12:,.0f}
"""
 
# 使用例: 10人チームでのROI計算
roi = AIDevelopmentROI(
    ai_tool_cost_monthly=200_000,      # 20万円/月（ツール費）
    training_cost=500_000,              # 50万円（研修費）
    infrastructure_cost_monthly=50_000, # 5万円/月（インフラ）
    productivity_loss_during_adoption=300_000,  # 導入期の生産性低下
    developer_hourly_rate=5_000,        # 時給5,000円
    team_size=10,
    hours_saved_per_dev_weekly=8,       # 週8時間節約
    defect_reduction_rate=0.3,          # 欠陥30%削減
    avg_defect_fix_cost=200_000,        # 欠陥修正コスト20万円
    monthly_defects_before=15,          # 月15件の欠陥
)
print(roi.generate_report())
# → 月間ROI: 700%超、投資回収: 0.5ヶ月

# BAD: AIに全てを委任し、人間が理解できないシステムが生まれる
class DangerousAutonomy:
    """AIが設計・実装・デプロイまで全自動で行い、
    人間は内部構造を理解していない"""
 
    def deploy_to_production(self, intent):
        system = self.ai.generate_entire_system(intent)
        # 人間のレビューなし！
        self.deploy(system)  # ← 何がデプロイされたか誰も知らない
 
    # 問題発生時に人間が対応できない
    def handle_incident(self, incident):
        # AIが生成したコードの構造を誰も理解していないため
        # 障害対応が極めて困難
        raise Exception("No human understands this system")
 
# GOOD: Human-in-the-Loop を維持
class SafeAutonomy:
    """AIが設計・実装を行うが、
    人間が理解・承認するゲートを設ける"""
 
    async def deploy_to_production(self, intent):
        system = await self.ai.generate_system(intent)
 
        # 人間が理解できる形で設計を説明
        explanation = await self.ai.explain_architecture(system)
        await self.human.review_and_approve(explanation)
 
        # 段階的デプロイ（カナリアリリース）
        await self.canary_deploy(system, traffic_percentage=5)
        await self.human.monitor_and_confirm()
        await self.full_deploy(system)

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

# セキュアコーディング例
import hashlib
import secrets
import hmac
from typing import Optional
 
class SecurityUtils:
    """セキュリティユーティリティ"""
 
    @staticmethod
    def generate_token(length: int = 32) -> str:
        """暗号学的に安全なトークン生成"""
        return secrets.token_urlsafe(length)
 
    @staticmethod
    def hash_password(password: str, salt: Optional[str] = None) -> tuple:
        """パスワードのハッシュ化"""
        if salt is None:
            salt = secrets.token_hex(16)
        hashed = hashlib.pbkdf2_hmac(
            'sha256',
            password.encode('utf-8'),
            salt.encode('utf-8'),
            iterations=100000
        )
        return hashed.hex(), salt
 
    @staticmethod
    def verify_password(password: str, hashed: str, salt: str) -> bool:
        """パスワードの検証"""
        new_hash, _ = SecurityUtils.hash_password(password, salt)
        return hmac.compare_digest(new_hash, hashed)
 
    @staticmethod
    def sanitize_input(value: str) -> str:
        """入力値のサニタイズ"""
        dangerous_chars = ['<', '>', '"', "'", '&', '\\']
        result = value
        for char in dangerous_chars:
            result = result.replace(char, '')
        return result.strip()
 
# 使用例
token = SecurityUtils.generate_token()
hashed, salt = SecurityUtils.hash_password("my_password")
is_valid = SecurityUtils.verify_password("my_password", hashed, salt)