# インストール（npm経由）
npm install -g @anthropic-ai/claude-code
 
# 初回起動（認証が必要）
claude
 
# バージョン確認
claude --version
 
# ヘルプ表示
claude --help
 
# 非対話モードで実行
claude -p "package.jsonの依存関係を一覧にして"
 
# ファイルをパイプで渡す
cat error.log | claude -p "このエラーログを分析して原因を特定して"
 
# 特定ディレクトリで実行
claude --cwd /path/to/project "テストを実行して失敗しているものを修正して"
 
# JSON形式で出力（スクリプト連携用）
claude -p "package.jsonのdependenciesを一覧にして" --output-format json
 
# 特定のモデルを指定して実行
claude --model claude-sonnet-4-20250514 -p "コードレビューして"
 
# 会話の継続（resume）
claude --resume  # 最後の会話を継続
claude --resume <session-id>  # 特定セッションを継続

# CLAUDE.md - プロジェクト固有のAI指示
 
## プロジェクト概要
ECプラットフォームのバックエンドAPI。Python 3.12 + FastAPI。
 
## コーディング規約
- 型ヒントは必須。Any型は禁止
- docstringはGoogle style
- テストはpytestで書く。カバレッジ80%以上
- import順: stdlib → third-party → local（isortで管理）
- エラーハンドリングはResult型（returns ライブラリ）
 
## アーキテクチャ
- Clean Architecture: domain/ → usecase/ → infra/ → presentation/
- ドメイン層は外部依存なし
- DI（依存注入）はdependency-injectorを使用
 
## データベース
- PostgreSQL 16 + SQLAlchemy 2.0
- マイグレーションはAlembic
- テスト用DBはSQLite in-memory
 
## テスト実行
```bash
pytest tests/ -v --cov=src --cov-report=term-missing

# バグ修正
claude "tests/test_order.py の test_cancel_shipped_order が
       失敗している。原因を調べて修正して"
 
# リファクタリング
claude "src/services/payment.py が300行を超えている。
       単一責任の原則に従って分割して"
 
# 新機能実装
claude "以下の仕様でクーポン機能を実装して:
       - クーポンコード: 英数字8桁
       - 割引タイプ: 定額 or 定率
       - 有効期限あり
       - 1ユーザー1回のみ使用可能
       テストも含めてお願い"
 
# コードレビュー
claude "git diff main...HEAD の変更をレビューして。
       セキュリティ、パフォーマンス、保守性の観点で"
 
# ドキュメント生成
claude "src/api/ 配下のエンドポイントを分析して
       OpenAPI仕様書を生成して。既存のdocs/api.yamlを更新"
 
# 依存関係の分析
claude "このプロジェクトの依存関係グラフを分析して
       循環依存がないか確認し、あれば解消案を提示して"

# 複雑なタスクを自律的に実行
claude "以下のステップでAPIのバージョンアップを行って:
1. OpenAPI仕様書(docs/api.yaml)を読んで現状を把握
2. 全エンドポイントにv2プレフィックスを追加
3. v1は後方互換のため残す（v2にリダイレクト）
4. 全テストを更新して通ることを確認
5. CHANGELOG.mdを更新"
 
# Claude Codeは以下を自律的に実行:
# - ファイルを読んで現状を分析
# - 必要な変更を計画
# - コードを修正
# - テストを実行
# - 失敗したら修正を繰り返す
# - 最終確認してレポート

# Task ツールを活用した並列調査
claude "以下の3つを並行して調査して:
1. src/services/ の全サービスクラスのメソッド一覧
2. tests/ のカバレッジが低いモジュール上位5つ
3. package.json の脆弱性のある依存パッケージ
それぞれの結果をまとめて報告して"
 
# Claude Codeは内部でTaskサブエージェントを生成し
# 並行して調査を実行する

// .claude/settings.json - MCP サーバー設定
{
  "mcpServers": {
    // PostgreSQLへの直接アクセス
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost:5432/mydb"
      }
    },
 
    // GitHubリポジトリ操作
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
 
    // Slack通知
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}"
      }
    },
 
    // Playwright（ブラウザテスト）
    "playwright": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-playwright"]
    },
 
    // Sentry（エラー監視）
    "sentry": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-sentry"],
      "env": {
        "SENTRY_AUTH_TOKEN": "${SENTRY_AUTH_TOKEN}",
        "SENTRY_ORG": "my-org"
      }
    }
  }
}

// custom-mcp-server.ts
// 社内システムと連携するカスタムMCPサーバーの例
 
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
const server = new Server(
  { name: "internal-tools", version: "1.0.0" },
  { capabilities: { tools: {} } }
);
 
// 社内チケットシステムとの連携
server.setRequestHandler("tools/list", async () => ({
  tools: [
    {
      name: "get_ticket",
      description: "社内チケットシステムからチケット情報を取得",
      inputSchema: {
        type: "object",
        properties: {
          ticket_id: { type: "string", description: "チケットID" }
        },
        required: ["ticket_id"]
      }
    },
    {
      name: "update_ticket_status",
      description: "チケットのステータスを更新",
      inputSchema: {
        type: "object",
        properties: {
          ticket_id: { type: "string" },
          status: {
            type: "string",
            enum: ["open", "in_progress", "review", "done"]
          },
          comment: { type: "string" }
        },
        required: ["ticket_id", "status"]
      }
    },
    {
      name: "search_wiki",
      description: "社内Wikiを検索",
      inputSchema: {
        type: "object",
        properties: {
          query: { type: "string", description: "検索クエリ" },
          category: { type: "string", description: "カテゴリ" }
        },
        required: ["query"]
      }
    }
  ]
}));
 
server.setRequestHandler("tools/call", async (request) => {
  const { name, arguments: args } = request.params;
 
  switch (name) {
    case "get_ticket":
      const ticket = await fetchFromInternalAPI(
        `/tickets/${args.ticket_id}`
      );
      return {
        content: [{ type: "text", text: JSON.stringify(ticket) }]
      };
 
    case "update_ticket_status":
      await updateInternalAPI(
        `/tickets/${args.ticket_id}`,
        { status: args.status, comment: args.comment }
      );
      return {
        content: [{ type: "text", text: "ステータスを更新しました" }]
      };
 
    case "search_wiki":
      const results = await searchInternalWiki(args.query, args.category);
      return {
        content: [{ type: "text", text: JSON.stringify(results) }]
      };
  }
});
 
const transport = new StdioServerTransport();
await server.connect(transport);

# .github/workflows/claude-review.yml
name: AI Code Review
 
on:
  pull_request:
    types: [opened, synchronize]
 
jobs:
  claude-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
 
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
 
      - name: Run AI Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # 差分を取得してClaude Codeにレビューを依頼
          DIFF=$(git diff origin/main...HEAD)
          claude -p "以下のコード差分をレビューしてください。
          セキュリティ、パフォーマンス、保守性の観点で問題を指摘し、
          改善案を提示してください。マークダウン形式で出力してください。
 
          $DIFF" > review.md
 
      - name: Post Review Comment
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## AI Code Review\n\n${review}`
            });

# .github/workflows/claude-test-gen.yml
name: AI Test Generation
 
on:
  pull_request:
    paths:
      - 'src/**/*.ts'
      - 'src/**/*.py'
 
jobs:
  generate-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Identify Changed Files
        id: changed
        run: |
          FILES=$(git diff --name-only origin/main...HEAD | grep -E '\.(ts|py)$' | grep -v test)
          echo "files=$FILES" >> $GITHUB_OUTPUT
 
      - name: Generate Tests
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude -p "以下の変更ファイルに対してテストが不足している箇所を
          特定し、テストコードを生成してください。
          既存のテストスタイルに合わせてください。
 
          変更ファイル: ${{ steps.changed.outputs.files }}"

#!/bin/bash
# scripts/ai-commit.sh
# AIによるコミットメッセージの自動生成
 
# ステージされた変更の差分を取得
STAGED_DIFF=$(git diff --cached)
 
if [ -z "$STAGED_DIFF" ]; then
    echo "ステージされた変更がありません"
    exit 1
fi
 
# Claude Codeにコミットメッセージを生成させる
MESSAGE=$(claude -p "以下のgit diffに基づいて、
Conventional Commitsの形式でコミットメッセージを生成してください。
1行目: type(scope): 簡潔な説明（50文字以内）
3行目以降: 変更の詳細（任意）
 
diff:
$STAGED_DIFF" --output-format text)
 
echo "生成されたコミットメッセージ:"
echo "$MESSAGE"
echo ""
read -p "このメッセージでコミットしますか？ (y/n): " CONFIRM
 
if [ "$CONFIRM" = "y" ]; then
    git commit -m "$MESSAGE"
    echo "コミットしました"
else
    echo "キャンセルしました"
fi

// .claude/settings.json - 権限管理
{
  "permissions": {
    // 許可するツールと範囲
    "allow": [
      "Read",                              // 全ファイル読み取り可
      "Write(src/**,tests/**,docs/**)",    // 特定ディレクトリのみ書き込み可
      "Bash(npm test,npm run *,pytest *)", // 特定コマンドのみ実行可
      "Grep",                              // 検索は無制限
      "Glob"                               // ファイル一覧も無制限
    ],
    // 明示的に拒否するツールと範囲
    "deny": [
      "Bash(rm -rf *)",          // 全削除禁止
      "Bash(git push --force*)", // 強制プッシュ禁止
      "Write(.env*)",            // 環境変数ファイル変更禁止
      "Write(*.pem)",            // 証明書ファイル変更禁止
      "Write(*.key)",            // 秘密鍵ファイル変更禁止
      "Read(.env*)",             // 環境変数ファイル読み取り禁止
      "Bash(curl *)",            // 外部通信禁止
      "Bash(wget *)"             // 外部ダウンロード禁止
    ]
  }
}

# Claude Code チームセキュリティポリシー
 
## 1. API キー管理
- 個人のAPI キーは環境変数で管理（.envに直書き禁止）
- チーム共有キーは AWS Secrets Manager 等で管理
- 月次でキーをローテーション
 
## 2. 操作制限
- 本番DBへの直接接続は禁止
- 本番環境のファイルシステムへのアクセスは禁止
- パッケージのインストール（npm install, pip install）は事前承認制
 
## 3. コードレビュー
- AI生成コードは通常のコードと同じレビュープロセスを適用
- セキュリティ関連コード（認証、暗号化等）は2名以上のレビュー必須
- AI生成コードであることをPRに明記
 
## 4. データ保護
- 個人情報を含むデータをプロンプトに含めない
- テスト用データは匿名化されたものを使用
- APIに送信されるコードの範囲を理解し管理する

# モノレポ構成でのClaude Code活用例
# packages/
# ├── frontend/     (React)
# ├── backend/      (FastAPI)
# ├── shared/       (共通型定義)
# └── infra/        (Terraform)
 
# 特定パッケージに対してタスクを実行
claude --cwd packages/backend "新しいAPIエンドポイントを追加して"
 
# パッケージ間の整合性チェック
claude "packages/shared/types.tsの型定義と
       packages/backend/schemas.pyのPydanticモデルが
       整合しているか確認して。不整合があれば修正して"
 
# インフラとアプリケーションの一貫した変更
claude "新しいマイクロサービスをデプロイするために:
1. packages/infra/にECSタスク定義を追加
2. packages/backend/に新しいサービスのスケルトンを生成
3. packages/shared/にサービス間通信の型を追加
4. docker-compose.ymlにサービスを追加"

# Step 1: 現状分析
claude "src/legacy/ ディレクトリのコードを分析して:
1. 使用されている技術・パターンを一覧化
2. テストカバレッジを確認
3. 依存関係グラフを作成
4. リスクの高いモジュール（循環依存、巨大ファイル等）を特定"
 
# Step 2: 移行計画の策定
claude "分析結果に基づいて、以下の条件で移行計画を立てて:
- 段階的に移行（ビッグバンは不可）
- 各フェーズでテストが通ること
- 移行中も既存機能が動作すること
- Strangler Fig パターンを適用"
 
# Step 3: 段階的な実行
claude "移行計画のPhase 1を実行して:
- UserService クラスをClean Architectureに分割
- 既存のテストを新構造に適応
- 新旧のコードが共存できるアダプターを作成"

# スキーマ変更の自動生成
claude "以下の要件でAlembicマイグレーションを作成して:
1. usersテーブルにemail_verifiedカラムを追加（boolean, default=false）
2. user_preferencesテーブルを新規作成
3. 既存データの移行スクリプトも含める
4. ロールバック手順も定義して"
 
# データ整合性チェック
claude "現在のSQLAlchemyモデル定義とDBスキーマの差分を検出して。
       models/ ディレクトリのモデルと
       alembic/versions/ の最新マイグレーションを比較して"

# ボトルネック調査
claude "以下のエンドポイントが遅い:
GET /api/v1/products?category=electronics&sort=price
 
1. src/api/products.py のクエリを分析
2. SQLAlchemyのクエリログから問題のSQLを特定
3. N+1クエリがないか確認
4. インデックスの提案
5. クエリ最適化の実装"
 
# ロードテスト結果の分析
claude "locustのテスト結果（results/load_test.csv）を分析して:
1. レスポンスタイムのp50, p95, p99を計算
2. スループットのボトルネックを特定
3. メモリリークの兆候がないか確認
4. 改善提案を優先度順にリストアップ"

# コードベースのセキュリティスキャン
claude "セキュリティの観点でコードベースを監査して:
1. ハードコードされたシークレットの検出
2. SQLインジェクションの可能性がある箇所
3. XSS脆弱性の可能性がある箇所
4. 認証・認可のバイパスが可能な箇所
5. 依存パッケージの既知の脆弱性
各問題の深刻度（Critical/High/Medium/Low）と修正方法も示して"

# 実装とドキュメントの同期
claude "src/api/ のエンドポイント実装と docs/api.yaml のOpenAPI仕様を比較して:
1. ドキュメントに記載がないエンドポイント
2. 実装と異なるパラメータ定義
3. レスポンスコードの不一致
不整合を全て修正して docs/api.yaml を更新して"

# Claude Codeのデバッグログを有効化
CLAUDE_CODE_DEBUG=1 claude "タスクを実行して"
 
# APIリクエストの詳細を確認
ANTHROPIC_LOG=debug claude -p "テスト"
 
# セッションログの確認
ls -la ~/.claude/logs/
# 各セッションのログが保存されている
 
# MCPサーバーの接続テスト
npx -y @modelcontextprotocol/server-postgres 2>&1
# エラーメッセージを確認

// BAD: 全ツールを無制限に許可
{
  "permissions": {
    "allow": ["*"]  // 危険！何でも実行できる
  }
}
 
// GOOD: 必要最小限の権限を設定
{
  "permissions": {
    "allow": [
      "Read",
      "Write(src/**,tests/**)",   // src/とtests/のみ書き込み可
      "Bash(npm test,npm run *)", // 特定コマンドのみ
      "Grep",
      "Glob"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Write(.env*)",
      "Write(*.pem)"
    ]
  }
}

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

# チーム間の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)

# マイグレーションスクリプトのテンプレート
import json
import logging
from pathlib import Path
from datetime import datetime
from typing import List, Dict, Callable
 
logger = logging.getLogger(__name__)
 
class MigrationRunner:
    """段階的マイグレーション実行エンジン"""
 
    def __init__(self, migration_dir: str):
        self.migration_dir = Path(migration_dir)
        self.migrations: List[Dict] = []
        self.completed: List[str] = []
 
    def register(self, version: str, description: str,
                 up: Callable, down: Callable):
        """マイグレーションの登録"""
        self.migrations.append({
            'version': version,
            'description': description,
            'up': up,
            'down': down,
            'registered_at': datetime.now().isoformat()
        })
 
    def run_up(self, target_version: str = None):
        """マイグレーションの実行（アップグレード）"""
        for migration in self.migrations:
            if migration['version'] in self.completed:
                continue
            logger.info(f"実行中: {migration['version']} - "
                       f"{migration['description']}")
            try:
                migration['up']()
                self.completed.append(migration['version'])
                logger.info(f"完了: {migration['version']}")
            except Exception as e:
                logger.error(f"失敗: {migration['version']}: {e}")
                raise
            if target_version and migration['version'] == target_version:
                break
 
    def run_down(self, target_version: str):
        """マイグレーションのロールバック"""
        for migration in reversed(self.migrations):
            if migration['version'] not in self.completed:
                continue
            if migration['version'] == target_version:
                break
            logger.info(f"ロールバック: {migration['version']}")
            migration['down']()
            self.completed.remove(migration['version'])
 
    def status(self) -> Dict:
        """マイグレーション状態の確認"""
        return {
            'total': len(self.migrations),
            'completed': len(self.completed),
            'pending': len(self.migrations) - len(self.completed),
            'versions': {
                m['version']: 'completed'
                if m['version'] in self.completed else 'pending'
                for m in self.migrations
            }
        }