AIコードの可読性を担保するレビュー基準と命名設計

// ファイルAでAIが生成
async function fetchUserData(userId: string) {
  const userData = await api.get(`/users/${userId}`);
  return userData;
}

// ファイルBで同じ概念をAIが生成（別のプロンプト）
async function getUserInfo(id: string) {
  const userInfo = await api.get(`/users/${id}`);
  return userInfo;
}

// ファイルCでさらに別の表現
async function loadMemberProfile(memberId: string) {
  const profile = await api.get(`/users/${memberId}`);
  return profile;
}

// naming-convention.md で "ユーザー取得は fetchUser + データ型" と合意
async function fetchUser(userId: UserId): Promise<User> {
  return api.get(`/users/${userId}`);
}

// すべてのファイルで同一パターンを使う
async function fetchUserList(filter: UserFilter): Promise<User[]> {
  return api.get('/users', { params: filter });
}

// ユーザーの表示名を取得するだけのロジックにAIがパターンを適用
interface UserDisplayStrategy {
  getDisplayName(user: User): string;
}

class FullNameStrategy implements UserDisplayStrategy {
  getDisplayName(user: User): string {
    return `${user.firstName} ${user.lastName}`;
  }
}

class UsernameStrategy implements UserDisplayStrategy {
  getDisplayName(user: User): string {
    return user.username;
  }
}

class UserDisplayNameFactory {
  static create(type: 'fullName' | 'username'): UserDisplayStrategy {
    return type === 'fullName' ? new FullNameStrategy() : new UsernameStrategy();
  }
}

// YAGNI: 今必要なのはフルネーム表示だけ
function getUserDisplayName(user: User): string {
  return `${user.firstName} ${user.lastName}`;
}

// ユーザーを取得する
const user = await fetchUser(userId);

// ユーザーが存在するかチェックする
if (!user) {
  // エラーをスローする
  throw new Error('User not found');
}

// ユーザーのメールアドレスを返す
return user.email;

const user = await fetchUser(userId);

if (!user) {
  // 削除済みユーザーへのアクセスはこのレイヤーで止める。
  // 上位でキャッチしてHTTP 404に変換する（error-handler.ts参照）
  throw new UserNotFoundError(userId);
}

return user.email;

// プロンプト: "ユーザーリストから条件に合うものを抽出して"
const result = users.filter(u => u.active && u.role === 'admin');
const data = result.map(u => ({ id: u.id, name: u.name }));
const final = data.sort((a, b) => a.name.localeCompare(b.name));
return final;

const activeAdmins = users.filter(
  (user) => user.active && user.role === 'admin'
);
const adminSummaries = activeAdmins.map((user) => ({
  id: user.id,
  name: user.name,
}));
return adminSummaries.sort((a, b) => a.name.localeCompare(b.name));

// auth/utils.ts でAIが生成
function formatUserName(firstName: string, lastName: string): string {
  return `${firstName} ${lastName}`.trim();
}

// profile/helpers.ts で別のタイミングにAIが生成
function buildFullName(first: string, last: string): string {
  return [first, last].filter(Boolean).join(' ');
}

// notification/formatter.ts でさらに生成
const getDisplayName = (user: { firstName: string; lastName: string }) =>
  `${user.firstName} ${user.lastName}`;

// shared/user-utils.ts に単一実装
export function formatUserDisplayName(
  firstName: string,
  lastName: string
): string {
  return [firstName, lastName].filter(Boolean).join(' ');
}

## AI生成コードレビューチェックリスト

### 命名の一貫性
- [ ] 関数名が命名規約（fetch/get/create/update/delete）に従っている
- [ ] 変数名がコンテキストから意味が読み取れる（result/data/tempは要確認）
- [ ] 同一概念の名前が既存コードと統一されている

### 抽象化の適切さ
- [ ] 抽象クラス・インターフェースの実装が2つ以上ある（1つなら要根拠）
- [ ] パターン（Factory/Strategy等）の適用に2つ以上のユースケースが想定される
- [ ] シンプルな処理に対して過剰なラッパーがない

### コメントの質
- [ ] コメントが「なぜ（why）」を説明している
- [ ] コードを読めばわかることだけのコメントが削除されている
- [ ] TODO/FIXMEがある場合、issueトラッカーへの参照がある

### 変数・定数の明示性
- [ ] マジックナンバーが名前付き定数に置き換えられている
- [ ] ループ変数・一時変数の名前が処理内容を表している

### 重複の確認
- [ ] 同一ロジックが既存コードに存在しないことをGrepで確認した
- [ ] 新規ユーティリティ関数は共有モジュールに配置されている

# 命名規約

## 動詞プレフィックスの使い分け
- `fetch*`: APIリクエストを伴う非同期取得 → fetchUser, fetchOrderList
- `get*`: メモリ内データの同期取得 → getUserById, getActiveItems
- `create*`: リソースの新規作成 → createUser, createOrder
- `update*`: 既存リソースの更新 → updateUserProfile, updateOrderStatus
- `delete*`: 論理削除・物理削除 → deleteUser, deleteOrder
- `is/has/can`: boolean返却 → isActive, hasPermission, canEdit

## 型・インターフェース命名
- エンティティ型: 名詞のみ（User, Order, Product）
- DTOは `Dto` サフィックス: UserDto, CreateOrderDto
- レスポンス型は `Response` サフィックス: FetchUserResponse

## 定数
- SCREAMING_SNAKE_CASE: MAX_RETRY_COUNT, DEFAULT_PAGE_SIZE

## ファイル命名
- コンポーネント: PascalCase（UserProfile.tsx）
- ユーティリティ: kebab-case（user-utils.ts）
- 定数ファイル: kebab-case（api-constants.ts）

pnpm add -D @typescript-eslint/eslint-plugin eslint-plugin-unicorn

import tsParser from '@typescript-eslint/parser';
import tsPlugin from '@typescript-eslint/eslint-plugin';
import unicorn from 'eslint-plugin-unicorn';

export default [
  {
    languageOptions: {
      parser: tsParser,
    },
    plugins: {
      '@typescript-eslint': tsPlugin,
      unicorn,
    },
    rules: {
      // 類型4対策: 意味のない変数名を禁止
      'unicorn/prevent-abbreviations': [
        'error',
        {
          replacements: {
            res: { response: true },
            req: { request: true },
            err: { error: true },
            val: { value: true },
            msg: { message: true },
          },
          allowList: {
            i: true, // forループインデックスは許容
          },
        },
      ],

      // 類型1対策: 命名パターンの強制（カスタム例）
      '@typescript-eslint/naming-convention': [
        'error',
        {
          selector: 'function',
          format: ['camelCase'],
        },
        {
          selector: 'variable',
          format: ['camelCase', 'UPPER_CASE'],
          leadingUnderscore: 'forbid',
        },
        {
          selector: 'interface',
          format: ['PascalCase'],
          custom: {
            regex: '^I[A-Z]',
            match: false, // "I" プレフィックスは禁止（Airbnbスタイル）
          },
        },
      ],
    },
  },
];

{
  "linter": {
    "rules": {
      "style": {
        "useNamingConvention": "error",
        "useFilenamingConvention": "error"
      },
      "complexity": {
        "noExcessiveCognitiveComplexity": {
          "level": "error",
          "options": { "maxAllowedComplexity": 15 }
        }
      }
    }
  }
}