# .github/workflows/ci.yml
name: CI                           # ワークフロー名
                                   # (GitHub UI の Actions タブに表示)
 
on:                                # トリガー
  push:
    branches: [main]
  pull_request:
    branches: [main]
 
jobs:                              # ジョブ定義
  test:                            # ジョブ ID (英数字とハイフン)
    runs-on: ubuntu-latest         # 実行環境
    steps:                         # ステップ
      - uses: actions/checkout@v4  # アクション呼び出し
      - run: echo "Hello, World!" # シェルコマンド実行

name: CI Pipeline
 
on:
  push:
    branches: [main]
    paths-ignore:
      - '**.md'
      - 'docs/**'
  pull_request:
    branches: [main]
 
# ワークフローレベルの権限設定
permissions:
  contents: read
  pull-requests: write
 
# 同じブランチの並行実行を制御
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
 
env:
  NODE_VERSION: '20'
 
jobs:
  lint-and-typecheck:
    name: Lint & Type Check
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'
 
      - name: Install dependencies
        run: npm ci
 
      - name: ESLint
        run: npm run lint
 
      - name: TypeScript
        run: npm run type-check
 
  test:
    name: Test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'
 
      - run: npm ci
      - run: npm test -- --coverage
 
      - name: Upload coverage
        if: github.event_name == 'pull_request'
        uses: actions/upload-artifact@v4
        with:
          name: coverage-report
          path: coverage/
 
  build:
    name: Build
    needs: [lint-and-typecheck, test]   # 両ジョブ成功後に実行
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'
 
      - run: npm ci
      - run: npm run build
 
      - uses: actions/upload-artifact@v4
        with:
          name: build-output
          path: dist/
          retention-days: 7

# YAML の基本構造
name: string          # ワークフロー名 (必須ではないが推奨)
 
on:                   # トリガー定義 (必須)
  event: ...
 
permissions:          # GITHUB_TOKEN の権限 (推奨: 最小権限)
  contents: read
  pull-requests: write
 
concurrency:          # 並行実行制御 (推奨: PR の重複実行を防ぐ)
  group: string
  cancel-in-progress: boolean
 
env:                  # ワークフローレベルの環境変数
  KEY: value
 
defaults:             # ジョブ/ステップのデフォルト設定
  run:
    shell: bash
    working-directory: ./app
 
jobs:                 # ジョブ定義 (必須)
  job-id:
    name: string              # 表示名
    runs-on: string           # ランナー (必須)
    needs: [job-id, ...]      # 依存ジョブ
    if: expression            # 実行条件
    timeout-minutes: number   # タイムアウト (デフォルト: 360分)
    continue-on-error: bool   # 失敗しても次のジョブに進む
    strategy:                 # マトリクス等
      matrix: ...
    env:                      # ジョブレベルの環境変数
      KEY: value
    outputs:                  # ジョブの出力
      key: value
    services:                 # サービスコンテナ
      name:
        image: ...
    steps:                    # ステップ (必須)
      - uses: action@version  # アクション
        with:                 # アクションの入力
          key: value
      - run: command          # シェルコマンド
        env:                  # ステップレベルの環境変数
          KEY: value

on:
  # Git イベント
  push:
    branches: [main, 'release/**']
    tags: ['v*']
    paths: ['src/**', 'package.json']
    paths-ignore: ['**.md']
 
  pull_request:
    types: [opened, synchronize, reopened]
    branches: [main]
 
  pull_request_target:
    types: [opened, synchronize]
    # Fork からの PR でも secrets にアクセス可能 (注意: セキュリティリスク)
 
  # スケジュール (cron)
  schedule:
    - cron: '0 9 * * 1'  # 毎週月曜 9:00 UTC
    - cron: '0 0 1 * *'  # 毎月1日 0:00 UTC
 
  # 手動実行
  workflow_dispatch:
    inputs:
      environment:
        description: 'Deploy environment'
        required: true
        type: choice
        options: [dev, staging, prod]
      dry_run:
        description: 'Dry run mode'
        type: boolean
        default: false
      version:
        description: 'Version to deploy'
        type: string
        required: false
 
  # 他のワークフローから呼び出し
  workflow_call:
    inputs:
      node-version:
        type: string
        default: '20'
    secrets:
      npm-token:
        required: true
 
  # リリースイベント
  release:
    types: [published]
 
  # Issue / PR コメント
  issue_comment:
    types: [created]
 
  # デプロイステータス
  deployment_status:
 
  # ラベル操作
  label:
    types: [created, edited, deleted]
 
  # ワークフロー完了
  workflow_run:
    workflows: ["CI"]
    types: [completed]
    branches: [main]

# push イベントのフィルタリング
on:
  push:
    # ブランチフィルタ (glob パターン対応)
    branches:
      - main
      - 'release/**'        # release/1.0, release/2.0 等
      - '!release/**-beta'  # release/1.0-beta を除外
    branches-ignore:
      - 'feature/**'
 
    # タグフィルタ
    tags:
      - 'v*'                # v1.0.0, v2.0.0 等
    tags-ignore:
      - 'v*-rc*'            # v1.0.0-rc1 を除外
 
    # パスフィルタ (変更されたファイルで絞り込み)
    paths:
      - 'src/**'
      - 'package.json'
      - '!src/**/*.test.ts'  # テストファイルの変更は除外
    paths-ignore:
      - '**.md'
      - 'docs/**'
      - '.github/**'

# 手動デプロイワークフロー
name: Manual Deploy
on:
  workflow_dispatch:
    inputs:
      environment:
        description: 'Target environment'
        required: true
        type: choice
        options:
          - dev
          - staging
          - production
      version:
        description: 'Image tag to deploy (e.g., v1.2.3 or abc1234)'
        required: true
        type: string
      skip_tests:
        description: 'Skip smoke tests after deploy'
        required: false
        type: boolean
        default: false
 
jobs:
  deploy:
    runs-on: ubuntu-latest
    environment: ${{ github.event.inputs.environment }}
    steps:
      - uses: actions/checkout@v4
 
      - name: Deploy
        run: |
          echo "Deploying ${{ github.event.inputs.version }} to ${{ github.event.inputs.environment }}"
          ./scripts/deploy.sh \
            --env ${{ github.event.inputs.environment }} \
            --version ${{ github.event.inputs.version }}
 
      - name: Smoke test
        if: github.event.inputs.skip_tests != 'true'
        run: ./scripts/smoke-test.sh ${{ github.event.inputs.environment }}

jobs:
  example:
    runs-on: ubuntu-latest
    steps:
      # 式の基本構文: ${{ expression }}
      - run: echo "Branch: ${{ github.ref_name }}"
      - run: echo "Actor: ${{ github.actor }}"
      - run: echo "SHA: ${{ github.sha }}"
      - run: echo "Event: ${{ github.event_name }}"
      - run: echo "Repository: ${{ github.repository }}"
      - run: echo "Run ID: ${{ github.run_id }}"
      - run: echo "Run Number: ${{ github.run_number }}"
 
      # 条件分岐
      - name: Deploy (main のみ)
        if: github.ref == 'refs/heads/main'
        run: ./deploy.sh
 
      # 前のステップの結果で条件分岐
      - name: On failure
        if: failure()
        run: echo "前のステップが失敗しました"
 
      # 常に実行 (クリーンアップ等)
      - name: Cleanup
        if: always()
        run: rm -rf tmp/
 
      # 式の中の関数
      - name: Contains check
        if: contains(github.event.head_commit.message, '[skip ci]')
        run: echo "CI skipped"
 
      - name: String comparison
        if: startsWith(github.ref, 'refs/tags/v')
        run: echo "Tag push detected"
 
      # 複合条件
      - name: Deploy on main push only
        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
        run: ./deploy.sh
 
      # PR からの実行かどうか
      - name: PR only
        if: github.event_name == 'pull_request'
        run: echo "Running on PR #${{ github.event.pull_request.number }}"

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      version: ${{ steps.version.outputs.value }}
      should-deploy: ${{ steps.check.outputs.deploy }}
    steps:
      - uses: actions/checkout@v4
 
      - id: version
        run: echo "value=$(cat package.json | jq -r .version)" >> "$GITHUB_OUTPUT"
 
      - id: check
        run: |
          if [[ "${{ github.ref }}" == "refs/heads/main" ]]; then
            echo "deploy=true" >> "$GITHUB_OUTPUT"
          else
            echo "deploy=false" >> "$GITHUB_OUTPUT"
          fi
 
  deploy:
    needs: build
    if: needs.build.outputs.should-deploy == 'true'
    runs-on: ubuntu-latest
    steps:
      - run: echo "Deploying version ${{ needs.build.outputs.version }}"

# 文字列関数
contains('Hello World', 'World')     # true
startsWith('Hello', 'He')            # true
endsWith('Hello', 'lo')              # true
format('Hello {0}', 'World')         # 'Hello World'
join(github.event.commits.*.message, ', ')  # コミットメッセージを結合
 
# 比較関数
success()                             # 前のステップが成功
failure()                             # 前のステップが失敗
always()                              # 常に実行
cancelled()                           # キャンセルされた
 
# JSON 関数
toJSON(github.event)                  # JSON に変換
fromJSON('{"key": "value"}')          # JSON をパース
 
# ハッシュ関数
hashFiles('**/package-lock.json')     # ファイルの SHA-256 ハッシュ
hashFiles('**/*.go', 'go.sum')        # 複数ファイルのハッシュ

steps:
  # リポジトリのチェックアウト
  - uses: actions/checkout@v4
    with:
      fetch-depth: 0  # 全履歴 (タグ取得等に必要)
      ref: ${{ github.head_ref }}  # PR のソースブランチ
      token: ${{ secrets.PAT }}    # プライベートサブモジュール用
 
  # Node.js セットアップ
  - uses: actions/setup-node@v4
    with:
      node-version: '20'
      node-version-file: '.node-version'  # ファイルからバージョン取得
      cache: 'npm'
      registry-url: 'https://npm.pkg.github.com'
 
  # Python セットアップ
  - uses: actions/setup-python@v5
    with:
      python-version: '3.12'
      cache: 'pip'
      cache-dependency-path: 'requirements*.txt'
 
  # Go セットアップ
  - uses: actions/setup-go@v5
    with:
      go-version: '1.22'
      go-version-file: 'go.mod'  # go.mod からバージョン取得
      cache: true
 
  # Java セットアップ
  - uses: actions/setup-java@v4
    with:
      distribution: 'temurin'
      java-version: '21'
      cache: 'maven'
 
  # キャッシュ
  - uses: actions/cache@v4
    with:
      path: ~/.npm
      key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
      restore-keys: |
        ${{ runner.os }}-npm-
 
  # アーティファクトのアップロード
  - uses: actions/upload-artifact@v4
    with:
      name: my-artifact
      path: |
        dist/
        !dist/**/*.map
      retention-days: 7
      if-no-files-found: error
 
  # アーティファクトのダウンロード
  - uses: actions/download-artifact@v4
    with:
      name: my-artifact
      path: dist/

# actions/github-script: JavaScript で GitHub API を操作
steps:
  - uses: actions/github-script@v7
    with:
      script: |
        // PR にコメントを追加
        await github.rest.issues.createComment({
          owner: context.repo.owner,
          repo: context.repo.repo,
          issue_number: context.issue.number,
          body: '## CI Results\n\nAll checks passed!'
        });
 
  - uses: actions/github-script@v7
    id: get-pr
    with:
      result-encoding: string
      script: |
        // PR のラベルを取得
        const { data: labels } = await github.rest.issues.listLabelsOnIssue({
          owner: context.repo.owner,
          repo: context.repo.repo,
          issue_number: context.issue.number,
        });
        return labels.map(l => l.name).join(',');
 
  - run: echo "Labels: ${{ steps.get-pr.outputs.result }}"

# Docker イメージのビルド&プッシュ
steps:
  - uses: actions/checkout@v4
 
  # Docker Buildx のセットアップ
  - uses: docker/setup-buildx-action@v3
 
  # コンテナレジストリへのログイン
  - uses: docker/login-action@v3
    with:
      registry: ghcr.io
      username: ${{ github.actor }}
      password: ${{ secrets.GITHUB_TOKEN }}
 
  # メタデータの生成 (タグ、ラベル)
  - uses: docker/metadata-action@v5
    id: meta
    with:
      images: ghcr.io/${{ github.repository }}
      tags: |
        type=sha,prefix=
        type=semver,pattern={{version}}
        type=semver,pattern={{major}}.{{minor}}
 
  # ビルド&プッシュ
  - uses: docker/build-push-action@v5
    with:
      context: .
      push: ${{ github.event_name != 'pull_request' }}
      tags: ${{ steps.meta.outputs.tags }}
      labels: ${{ steps.meta.outputs.labels }}
      cache-from: type=gha
      cache-to: type=gha,mode=max
      platforms: linux/amd64,linux/arm64

jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_USER: test
          POSTGRES_PASSWORD: test
          POSTGRES_DB: testdb
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
 
      redis:
        image: redis:7-alpine
        ports:
          - 6379:6379
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
 
      elasticsearch:
        image: elasticsearch:8.11.0
        ports:
          - 9200:9200
        env:
          discovery.type: single-node
          xpack.security.enabled: "false"
        options: >-
          --health-cmd "curl -f http://localhost:9200/_cluster/health"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 10
 
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm run test:integration
        env:
          DATABASE_URL: postgresql://test:test@localhost:5432/testdb
          REDIS_URL: redis://localhost:6379
          ELASTICSEARCH_URL: http://localhost:9200

# ワークフローレベルで権限を制限 (推奨)
permissions:
  contents: read        # リポジトリの読み取り
  pull-requests: write  # PR へのコメント
  issues: write         # Issue の操作
 
# ジョブレベルで上書き
jobs:
  deploy:
    permissions:
      id-token: write   # OIDC 認証用
      contents: read
    steps: ...
 
  comment:
    permissions:
      pull-requests: write
    steps: ...

# PR ごとに最新の実行のみを保持 (古い実行をキャンセル)
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
 
# 例: 同じ PR に対して push が連続した場合
# Push 1 → CI 開始
# Push 2 → Push 1 の CI をキャンセル → Push 2 の CI 開始
# Push 3 → Push 2 の CI をキャンセル → Push 3 の CI 開始
 
# デプロイは並行実行を禁止 (キャンセルはしない)
concurrency:
  group: deploy-${{ github.event.inputs.environment }}
  cancel-in-progress: false
# → 前のデプロイ完了を待ってから次のデプロイを開始

# ワークフローレベル
env:
  NODE_VERSION: '20'
  CI: true
 
jobs:
  build:
    # ジョブレベル
    env:
      BUILD_MODE: production
    steps:
      # ステップレベル
      - run: npm run build
        env:
          VITE_API_URL: https://api.example.com
 
      # 動的に環境変数を設定 (後続ステップで使用可能)
      - run: echo "VERSION=1.2.3" >> "$GITHUB_ENV"
      - run: echo "Version is $VERSION"  # 1.2.3

steps:
  # 出力の設定
  - id: extract
    run: |
      echo "version=$(cat package.json | jq -r .version)" >> "$GITHUB_OUTPUT"
      echo "commit_count=$(git rev-list --count HEAD)" >> "$GITHUB_OUTPUT"
 
      # 複数行の出力
      echo "changelog<<EOF" >> "$GITHUB_OUTPUT"
      git log --oneline -5 >> "$GITHUB_OUTPUT"
      echo "EOF" >> "$GITHUB_OUTPUT"
 
  # 出力の参照
  - run: |
      echo "Version: ${{ steps.extract.outputs.version }}"
      echo "Commits: ${{ steps.extract.outputs.commit_count }}"
      echo "Changelog:"
      echo "${{ steps.extract.outputs.changelog }}"

# 悪い例: 1つのワークフローに全てを詰め込む
name: Everything
on: [push]
jobs:
  everything:
    runs-on: ubuntu-latest
    steps:
      - run: npm run lint        # 10s
      - run: npm test            # 60s
      - run: npm run build       # 30s
      - run: npm run e2e         # 300s
      - run: docker build .      # 120s
      - run: ./deploy.sh         # 60s
      # 合計 ~10分、1つ失敗すると全てやり直し
 
# 改善: ジョブを分割して並列実行
name: CI
on: [push]
jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm run lint
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm test
  build:
    needs: [lint, test]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm run build

# 悪い例: バージョンが散在
steps:
  - uses: actions/checkout@v4
  - uses: actions/setup-node@v4
    with:
      node-version: '20'
  - run: npm ci
  - run: npm test
 
# 別のワークフローでも同じ定義を繰り返す...
 
# 改善: 環境変数やReusable Workflowで一元管理
env:
  NODE_VERSION: '20'
 
jobs:
  ci:
    uses: ./.github/workflows/reusable-ci.yml
    with:
      node-version: '20'

# 悪い例: Fork PR で secrets を使用
on:
  pull_request_target:
    types: [opened, synchronize]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.pull_request.head.sha }}
          # Fork の信頼できないコードをチェックアウト
      - run: npm ci && npm test
        env:
          SECRET_KEY: ${{ secrets.SECRET_KEY }}
          # → Fork PR からシークレットが漏洩するリスク!
 
# 改善: pull_request_target では信頼できないコードを実行しない
# または、ラベルベースの承認フローを導入

# 悪い例: 毎回依存関係をインストール
steps:
  - uses: actions/checkout@v4
  - uses: actions/setup-node@v4
    with:
      node-version: '20'
      # cache: 'npm'  ← これがない!
  - run: npm ci  # 毎回 90 秒
 
# 改善: キャッシュを活用
steps:
  - uses: actions/checkout@v4
  - uses: actions/setup-node@v4
    with:
      node-version: '20'
      cache: 'npm'  # ← キャッシュ有効化
  - run: npm ci  # キャッシュヒット時は 3 秒

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

steps:
  - name: Workflow commands demo
    run: |
      # グループ化 (折りたたみ可能なログセクション)
      echo "::group::Dependencies Installation"
      npm ci
      echo "::endgroup::"
 
      # 警告メッセージ
      echo "::warning file=src/app.js,line=10,col=5::Deprecated API usage"
 
      # エラーメッセージ
      echo "::error file=src/app.js,line=20::Missing required import"
 
      # デバッグメッセージ (ACTIONS_STEP_DEBUG=true の場合のみ表示)
      echo "::debug::Current working directory: $(pwd)"
 
      # 通知メッセージ
      echo "::notice::Build completed successfully"
 
      # 値のマスク (ログから隠す)
      DYNAMIC_SECRET=$(some-command)
      echo "::add-mask::$DYNAMIC_SECRET"
      echo "Using secret: $DYNAMIC_SECRET"  # *** と表示される

steps:
  - name: Generate job summary
    run: |
      # Job Summary にMarkdownで情報を追加
      echo "## Build Report" >> $GITHUB_STEP_SUMMARY
      echo "" >> $GITHUB_STEP_SUMMARY
      echo "| Item | Status |" >> $GITHUB_STEP_SUMMARY
      echo "|------|--------|" >> $GITHUB_STEP_SUMMARY
      echo "| Lint | :white_check_mark: Pass |" >> $GITHUB_STEP_SUMMARY
      echo "| Test | :white_check_mark: Pass |" >> $GITHUB_STEP_SUMMARY
      echo "| Build | :white_check_mark: Pass |" >> $GITHUB_STEP_SUMMARY
      echo "" >> $GITHUB_STEP_SUMMARY
      echo "**Duration**: 3m 42s" >> $GITHUB_STEP_SUMMARY
      echo "" >> $GITHUB_STEP_SUMMARY
 
      # コードブロック
      echo '```' >> $GITHUB_STEP_SUMMARY
      echo "Node: $(node --version)" >> $GITHUB_STEP_SUMMARY
      echo "npm: $(npm --version)" >> $GITHUB_STEP_SUMMARY
      echo '```' >> $GITHUB_STEP_SUMMARY
 
  - name: Coverage summary
    run: |
      # テストカバレッジの要約
      COVERAGE=$(npx jest --coverage --coverageReporters=text-summary 2>/dev/null | tail -5)
      echo "### Test Coverage" >> $GITHUB_STEP_SUMMARY
      echo '```' >> $GITHUB_STEP_SUMMARY
      echo "$COVERAGE" >> $GITHUB_STEP_SUMMARY
      echo '```' >> $GITHUB_STEP_SUMMARY

# ワークフローレベルでデフォルトシェルを設定
defaults:
  run:
    shell: bash
    working-directory: ./app
 
jobs:
  build:
    runs-on: ubuntu-latest
    # ジョブレベルで上書き可能
    defaults:
      run:
        working-directory: ./app/frontend
    steps:
      - uses: actions/checkout@v4
 
      # デフォルト: bash + ./app/frontend
      - run: npm ci
 
      # ステップレベルで上書き
      - run: pip install -r requirements.txt
        shell: bash
        working-directory: ./app/backend
 
      # Windows ランナーでの PowerShell
      # - run: Get-ChildItem
      #   shell: pwsh
 
      # Python スクリプトとして実行
      - run: |
          import json
          with open('package.json') as f:
              data = json.load(f)
              print(f"Version: {data['version']}")
        shell: python