# .cursorrules
 
## 技術スタック
- Next.js 14 (App Router)
- TypeScript 5.4 (strict mode)
- Tailwind CSS 3.4
- Prisma (ORM)
- tRPC (API)
 
## コーディング規約
- コンポーネントは function 宣言で書く（アロー関数禁止）
- CSS はTailwind のみ使用（CSS Modules禁止）
- 状態管理は Zustand を使用
- フォームは React Hook Form + Zod
- データフェッチは TanStack Query
 
## ファイル命名
- コンポーネント: PascalCase (UserProfile.tsx)
- ユーティリティ: camelCase (formatDate.ts)
- 定数: SCREAMING_SNAKE_CASE
- テスト: *.test.ts / *.test.tsx
 
## 禁止事項
- any型の使用
- console.logの本番コードへの残存
- useEffect内でのデータフェッチ
- 200行を超えるコンポーネント

// Cmd+I でComposerを開き、マルチファイル編集を指示
 
// プロンプト例:
// "ユーザープロファイルページを作成して。
//  以下のファイルを生成:
//  1. app/profile/page.tsx - プロファイル表示ページ
//  2. components/ProfileCard.tsx - プロファイルカード
//  3. hooks/useProfile.ts - プロファイル取得フック
//  4. lib/api/profile.ts - API呼び出し
//  5. __tests__/ProfileCard.test.tsx - テスト"
 
// → Composerが5ファイルを同時に生成・編集
// → 各ファイルの差分をプレビューで確認可能
// → Accept / Reject を選択

// Agent Modeでの開発フロー
// Cmd+. で Agent Mode を有効化
 
// === プロンプト例 1: 機能実装 ===
// "通知システムを実装して:
//  1. NotificationServiceクラスを作成
//  2. WebSocket接続でリアルタイム通知
//  3. 通知の永続化（DBに保存）
//  4. 未読カウントのAPI
//  5. テストを含める
//  6. テストを実行して全て通ることを確認"
 
// Agent Modeが実行する内容:
// Step 1: 関連ファイルの調査
//   → プロジェクト構造の把握
//   → 既存のサービスパターンの確認
//
// Step 2: ファイル生成・編集
//   → src/services/notification.ts
//   → src/api/notifications/route.ts
//   → src/hooks/useNotifications.ts
//   → prisma/schema.prisma (スキーマ追加)
//
// Step 3: テスト実行
//   → npm test -- --watch=false
//   → 失敗したテストの自動修正
//
// Step 4: 結果レポート
//   → 変更したファイルの一覧
//   → テスト結果のサマリー
 
// === プロンプト例 2: バグ修正 ===
// "ユーザーがプロフィール画像をアップロードすると
//  500エラーが発生する。原因を調査して修正して。
//  1. エラーログを確認
//  2. 関連コードを調査
//  3. 原因を特定
//  4. 修正を実装
//  5. テストを追加して確認"

// .vscode/settings.json（Cursorでも有効）
{
  // AI補完の設定
  "cursor.cpp.enablePartialAccepts": true,  // 部分的な補完の受け入れ
  "cursor.chat.defaultModel": "claude-sonnet-4-20250514",
 
  // コンテキスト設定
  "cursor.chat.alwaysSearchWeb": false,      // 必要時のみWeb検索
  "cursor.general.enableShadowWorkspace": true, // バックグラウンドインデックス
 
  // 補完の挙動
  "editor.inlineSuggest.enabled": true,
  "editor.suggest.preview": true,
 
  // AI関連のファイル除外（パフォーマンス最適化）
  "cursor.general.ignoredPaths": [
    "node_modules",
    ".next",
    "dist",
    "coverage",
    "*.min.js",
    "*.bundle.js"
  ]
}

// Windsurf Cascade でのリファクタリング例
 
// プロンプト: "このファイルをClean Architectureに分割して"
 
// Before: 単一ファイルに全てが混在
// src/features/todo.ts (200行)
 
// After: Cascadeが自動分割
// src/features/todo/
// ├── domain/
// │   ├── Todo.ts          (エンティティ)
// │   └── TodoRepository.ts (リポジトリインターフェース)
// ├── application/
// │   ├── CreateTodoUseCase.ts
// │   ├── CompleteTodoUseCase.ts
// │   └── ListTodosUseCase.ts
// ├── infrastructure/
// │   └── PrismaTodoRepository.ts
// └── presentation/
//     ├── TodoController.ts
//     └── todoRouter.ts
 
// Cascadeは既存のimportパスも全て自動更新する

// Supercompleteの動作例
 
// ユーザーが入力し始めると、Supercompleteがブロック単位で補完を提案
 
// 入力: "async function fetchUser"
// Supercomplete提案（ブロック単位）:
async function fetchUserById(userId: string): Promise<User | null> {
  try {
    const response = await prisma.user.findUnique({
      where: { id: userId },
      include: {
        profile: true,
        preferences: true,
      },
    });
 
    if (!response) {
      return null;
    }
 
    return mapToUser(response);
  } catch (error) {
    logger.error('Failed to fetch user', { userId, error });
    throw new DatabaseError('User fetch failed', { cause: error });
  }
}
 
// 特徴:
// - 行単位ではなく関数全体を提案
// - プロジェクトの既存パターン（prisma, logger, エラー型）を学習
// - try-catchパターンやエラーハンドリングも含む
// - 直前の編集内容（例: 別のfetch関数）のパターンを踏襲

# .cursorrules - チーム共通テンプレート
 
## プロジェクト情報
- プロジェクト名: {project_name}
- リポジトリ: {repo_url}
- 主要な技術スタック: {tech_stack}
 
## アーキテクチャ
- パターン: {architecture_pattern}
- ディレクトリ構成の説明:
  - src/domain/  : ビジネスロジック（外部依存なし）
  - src/app/     : アプリケーション層
  - src/infra/   : インフラストラクチャ（DB、外部API）
  - src/ui/      : プレゼンテーション層
 
## コーディング規約
- 言語バージョン: {language_version}
- リンター: {linter_config}
- フォーマッター: {formatter_config}
- テストフレームワーク: {test_framework}
- カバレッジ目標: {coverage_target}
 
## AI生成コードの品質基準
- 型安全性: strict mode必須、any禁止
- エラーハンドリング: Result型 or 明示的な例外
- テスト: 生成コードには必ずテストを含める
- ドキュメント: public関数にはJSDoc/docstring必須
- 命名: ドメイン用語集（glossary.md）に従う
 
## 禁止事項
- 機密情報のハードコード
- console.log/printの本番コードへの残存
- テストなしのビジネスロジック
- 200行を超えるファイル
- 循環依存の導入
 
## レビュー注意事項
- AI生成コードは必ず人間がレビューする
- セキュリティ関連は2名以上でレビュー
- パフォーマンス影響がある変更はベンチマーク必須

# AI IDE セキュリティチェックリスト
 
## 1. ファイル除外設定
- [ ] .cursorignore に機密ファイルを追加
  - .env, .env.*, .env.local
  - *.pem, *.key, *.cert
  - credentials.json, secrets.yaml
  - .aws/, .ssh/
 
## 2. プライバシー設定
- [ ] Privacy Mode を有効化（学習データ非利用）
- [ ] テレメトリ設定を確認
- [ ] チームのセキュリティポリシーに準拠
 
## 3. コードの送信範囲
- [ ] どのファイルがAIに送信されるか把握
- [ ] 機密コード（認証、暗号化）の扱いを定義
- [ ] 顧客データを含むファイルの取り扱い
 
## 4. 拡張機能の管理
- [ ] 信頼できるソースの拡張機能のみ使用
- [ ] AI系拡張機能の重複がないか確認
- [ ] 不要な拡張機能を無効化
 
## 5. ネットワーク
- [ ] VPN経由での利用を確認
- [ ] プロキシ設定が適切か確認
- [ ] ファイアウォールルールの確認

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