# VS Code に拡張機能をインストール
code --install-extension GitHub.copilot
code --install-extension GitHub.copilot-chat
 
# GitHub アカウントでサインイン
# VS Code 左下のアカウントアイコン → Sign in with GitHub
 
# プラン確認
# GitHub → Settings → Copilot → ライセンスタイプ確認
# Individual: $10/月
# Business: $19/月 (組織管理、IP保護)
# Enterprise: $39/月 (カスタマイズ、監査ログ)

// .vscode/settings.json
{
  // Copilot の基本設定
  "github.copilot.enable": {
    "*": true,
    "plaintext": false,
    "markdown": true,
    "yaml": true
  },
 
  // インライン候補の表示
  "editor.inlineSuggest.enabled": true,
 
  // 言語ごとの無効化 (機密ファイル)
  "github.copilot.enable": {
    "dotenv": false,
    "properties": false,
    "ini": false
  },
 
  // Copilot Chat の設定
  "github.copilot.chat.localeOverride": "ja",
 
  // エディタ内での候補表示設定
  "github.copilot.editor.enableAutoCompletions": true,
 
  // Next Edit Suggestions (NES) の有効化
  "github.copilot.nextEditSuggestions.enabled": true
}

// ─── テクニック 1: 関数シグネチャ + コメントで誘導 ───
 
// ユーザーの年齢を検証する。18歳未満は不可。
// エラー時は具体的なメッセージを返す。
function validateAge(age: unknown): { valid: boolean; message: string } {
  // ← Copilot が適切な実装を提案
}
 
// ─── テクニック 2: テストケースを先に書く (TDD) ───
 
describe('calculateDiscount', () => {
  it('通常会員は5%割引', () => {
    expect(calculateDiscount(1000, 'normal')).toBe(950);
  });
  it('プレミアム会員は15%割引', () => {
    expect(calculateDiscount(1000, 'premium')).toBe(850);
  });
  it('割引後の金額は0未満にならない', () => {
    expect(calculateDiscount(10, 'premium')).toBe(0);
  });
});
// → テストから実装を自動生成させる
 
// ─── テクニック 3: 型定義から実装を生成 ───
 
type SortDirection = 'asc' | 'desc';
 
interface SortOptions<T> {
  data: T[];
  key: keyof T;
  direction: SortDirection;
}
 
function sortBy<T>(options: SortOptions<T>): T[] {
  // ← 型情報から正確な実装が提案される
}
 
// ─── テクニック 4: 例示パターン (Few-shot) ───
 
// 既にある関数の隣に同様の関数を書くと、パターンを学習して提案
function getUserById(id: string): Promise<User> {
  return db.users.findUnique({ where: { id } });
}
 
function getPostById(id: string): Promise<Post> {
  // ← 上の関数のパターンから正確に推論
}
 
// ─── テクニック 5: JSDoc で意図を明示 ───
 
/**
 * CSV ファイルを読み込み、指定されたカラムでグループ化する
 * @param filePath CSVファイルのパス
 * @param groupBy グループ化するカラム名
 * @returns グループ化されたデータ
 * @throws FileNotFoundError ファイルが存在しない場合
 * @example
 * const result = await groupCsvByColumn('./data.csv', 'department');
 * // { 'engineering': [...], 'marketing': [...] }
 */
async function groupCsvByColumn(
  filePath: string,
  groupBy: string
): Promise<Record<string, any[]>> {
  // ← JSDoc の情報から正確な実装が提案される
}

# npm でインストール
npm install -g @anthropic-ai/claude-code
 
# 認証
claude auth login
 
# バージョン確認
claude --version
 
# アップデート
npm update -g @anthropic-ai/claude-code

# インタラクティブモードで起動
claude
 
# ワンショットコマンド
claude "このプロジェクトの構造を説明して"
 
# パイプで入力
cat error.log | claude "このエラーの原因を分析して"
 
# 特定ファイルを指定
claude "この関数のテストを書いて" --file src/utils/validate.ts
 
# 出力形式の指定
claude --output-format json "package.json の依存関係を分析して"
 
# ─── セッション管理 ───
claude --resume         # 前回のセッションを再開
claude --session-id abc  # 特定セッションを再開
 
# ─── モデル指定 ───
# デフォルトは最新の Claude モデル
# API キーに応じたモデルが使用される

# CLAUDE.md (プロジェクトルートに配置)
 
## プロジェクト概要
TypeScript + React のWebアプリケーション
バックエンドは Express + Prisma
 
## 技術スタック
- Frontend: React 19, TypeScript, Tailwind CSS, Zustand
- Backend: Express, Prisma, PostgreSQL
- Testing: Vitest, React Testing Library, Playwright
- CI/CD: GitHub Actions
- Deploy: Vercel (Frontend), Railway (Backend)
 
## コーディング規約
- 関数コンポーネントのみ使用 (クラスコンポーネント禁止)
- 状態管理は Zustand を使用
- スタイリングは Tailwind CSS
- テストは Vitest + Testing Library
- エラーハンドリングは Result 型パターン
- `any` 型の使用禁止
- console.log の使用禁止 (logger を使用)
 
## ディレクトリ構造

# CLAUDE.md は複数の場所に配置可能
# 優先順位: ローカル > プロジェクト > グローバル
 
~/.claude/CLAUDE.md              # グローバル設定 (全プロジェクト共通)
~/projects/my-app/CLAUDE.md      # プロジェクトルート
~/projects/my-app/src/CLAUDE.md  # サブディレクトリ (追加ルール)
 
# グローバル CLAUDE.md の例
# ~/.claude/CLAUDE.md
# ---
# ## 共通ルール
# - 日本語でコメントを書くこと
# - TypeScript を使用する場合は strict モードを有効にする
# - テストは必ずユニットテストと統合テストを含める
# - コミットメッセージは Conventional Commits に従う

# インタラクティブモード内で使用
/help           # ヘルプ表示
/clear          # 会話履歴をクリア
/compact        # コンテキストを圧縮 (メモリ節約)
/config         # 設定の確認・変更
/cost           # 現在のセッションのコスト表示
/doctor         # 環境診断
/init           # CLAUDE.md の初期化
/review         # コードレビューモード
/terminal       # ターミナルコマンド実行
 
# MCP (Model Context Protocol) ツール
/mcp            # MCP サーバーの管理

// ~/.claude/claude_desktop_config.json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://localhost:5432/mydb"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/docs"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "..."
      }
    }
  }
}

# macOS
brew install --cask cursor
 
# VS Code 設定のインポート
# Cursor 初回起動時に "Import VS Code Settings" を選択
# → 拡張機能、設定、キーバインドが自動移行

# .cursorrules (プロジェクトルートに配置)
 
You are an expert TypeScript developer working on a React + Express application.
 
## Code Style
- Use functional programming patterns
- Prefer immutable data structures
- Always use explicit return types for functions
- Use descriptive variable names (no abbreviations)
- Maximum function length: 30 lines
- Maximum file length: 300 lines
 
## Framework Conventions
- React: Use functional components with hooks
- State: Zustand for global, useState for local
- Styling: Tailwind CSS utility classes
- Testing: Vitest + React Testing Library
- API: tRPC for type-safe API calls
 
## Error Handling
- Always use Result pattern for error handling
- Never use try-catch in business logic (only in infrastructure layer)
- Log errors with structured logging (pino)
- Return user-friendly error messages
 
## File Naming
- Components: PascalCase (UserProfile.tsx)
- Hooks: camelCase with use prefix (useAuth.ts)
- Utils: camelCase (formatDate.ts)
- Types: PascalCase (User.ts)
- Tests: *.test.ts or *.spec.ts
 
## Do Not
- Never use `any` type
- Never use `console.log` in production code
- Never mutate function arguments
- Never use `var` (use `const` or `let`)
- Never commit TODO comments without issue reference
- Never use inline styles (use Tailwind)
 
## When Writing Tests
- Use describe/it blocks with clear descriptions in Japanese
- Mock external dependencies
- Test edge cases and error scenarios
- Aim for >80% code coverage
- Use factory functions for test data
 
## Commit Messages
- Follow Conventional Commits format
- Subject in English, body in Japanese is OK

# Cursor の @docs で外部ドキュメントを参照可能
# Cursor Settings → Features → Docs → Add
 
# 追加推奨ドキュメント:
# - React: https://react.dev
# - Next.js: https://nextjs.org/docs
# - Tailwind CSS: https://tailwindcss.com/docs
# - Prisma: https://www.prisma.io/docs
# - tRPC: https://trpc.io/docs
# - Vitest: https://vitest.dev/guide/
 
# 使い方:
# Chat で "@docs React の useEffect の正しい使い方を教えて"
# → React 公式ドキュメントの内容を踏まえた回答

// .vscode/settings.json
{
  // 機密ファイルでの Copilot 無効化
  "github.copilot.enable": {
    "dotenv": false,
    "properties": false,
    "ini": false
  },
 
  // Telemetry の制限
  "github.copilot.advanced": {
    // 公開コードと類似する提案をブロック
    "duplicationDetection": "block"
  }
}

# .gitignore に AI 関連の設定ファイルを追加
echo '.cursorrules' >> .gitignore  # 必要に応じて
# CLAUDE.md はコミットする (チーム共有のため)
 
# ─── .aiignore (Claude Code 用) ───
# Claude Code に読ませたくないファイルを指定
cat << 'EOF' > .aiignore
# 機密ファイル
.env
.env.*
secrets/
credentials/
*.pem
*.key
 
# 大きなバイナリ
*.zip
*.tar.gz
node_modules/
dist/
build/
 
# 生成ファイル
coverage/
.next/
EOF

# .github/workflows/ai-code-quality.yml
name: AI Code Quality Check
on: [pull_request]
 
jobs:
  quality-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Type Check
        run: npx tsc --noEmit
 
      - name: Lint
        run: npx eslint . --max-warnings 0
 
      - name: Security Audit
        run: npm audit --audit-level=moderate
 
      - name: Test
        run: npm test -- --coverage
 
      - name: Coverage Check
        run: |
          COVERAGE=$(npx coverage-summary | grep 'All files' | awk '{print $NF}')
          if (( $(echo "$COVERAGE < 80" | bc -l) )); then
            echo "Coverage is below 80%: $COVERAGE"
            exit 1
          fi
 
      - name: License Check
        run: npx license-checker --failOn 'GPL'
 
      - name: Bundle Size
        run: npx size-limit

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