┌─────────────────────────────────────────────────────────┐
│                    Presentation Layer                    │
│         （Vue 3 / API Gateway / REST Controller）        │
├─────────────────────────────────────────────────────────┤
│                    Application Layer                     │
│            （Use Case / Application Service）            │
├─────────────────────────────────────────────────────────┤
│                      Domain Layer                        │
│         （Domain Model / Business Rules / Events）       │
├─────────────────────────────────────────────────────────┤
│                   Infrastructure Layer                   │
│     （Repository Impl / External API / MQ / Cache）      │
└─────────────────────────────────────────────────────────┘

src/main/java/com/company/project/
├── controller/                    # Presentation Layer
│   ├── CustomerController.java
│   └── dto/
│       ├── request/
│       │   └── CreateCustomerRequest.java
│       └── response/
│           └── CustomerResponse.java
│
├── application/                   # Application Layer
│   ├── service/
│   │   └── CustomerApplicationService.java
│   ├── usecase/
│   │   └── CreateCustomerUseCase.java
│   └── mapper/
│       └── CustomerDtoMapper.java
│
├── domain/                        # Domain Layer
│   ├── model/
│   │   └── Customer.java
│   ├── service/
│   │   └── CustomerDomainService.java
│   ├── repository/
│   │   └── CustomerRepository.java        # 介面
│   ├── event/
│   │   └── CustomerCreatedEvent.java
│   └── exception/
│       └── CustomerNotFoundException.java
│
├── infrastructure/                # Infrastructure Layer
│   ├── persistence/
│   │   ├── entity/
│   │   │   └── CustomerEntity.java
│   │   ├── repository/
│   │   │   └── CustomerRepositoryImpl.java  # 實作
│   │   └── mapper/
│   │       └── CustomerEntityMapper.java
│   ├── external/
│   │   ├── payment/
│   │   └── notification/
│   └── config/
│       ├── SecurityConfig.java
│       └── RedisConfig.java
│
└── common/
    ├── exception/
    │   └── GlobalExceptionHandler.java
    ├── util/
    └── constant/

# Windows - 使用 winget 安裝
winget install Microsoft.VisualStudioCode

# 或從官方網站下載
# https://code.visualstudio.com/

# 批次安裝擴充套件
code --install-extension GitHub.copilot
code --install-extension GitHub.copilot-chat
code --install-extension vscjava.vscode-java-pack
code --install-extension vmware.vscode-spring-boot
code --install-extension Vue.volar
code --install-extension bradlc.vscode-tailwindcss
code --install-extension eamodio.gitlens
code --install-extension SonarSource.sonarlint-vscode

# Windows
winget install Git.Git

# 基本設定
git config --global user.name "您的姓名"
git config --global user.email "your.email@company.com"
git config --global core.autocrlf true
git config --global init.defaultBranch main

# SSH 金鑰設定
ssh-keygen -t ed25519 -C "your.email@company.com"
# 將公鑰加入 GitHub Settings > SSH Keys

# Windows
winget install GitHub.cli

# 認證
gh auth login

# 驗證安裝
gh auth status

# 安裝 JDK 21（推薦 Temurin）
winget install EclipseAdoptium.Temurin.21.JDK

# 安裝 Maven
winget install Apache.Maven

# 驗證
java -version
mvn -version

# 安裝 Node.js LTS
winget install OpenJS.NodeJS.LTS

# 驗證
node -v
npm -v

{
  // Copilot 基本設定
  "github.copilot.enable": {
    "*": true,
    "markdown": true,
    "yaml": true
  },

  // Chat 設定
  "chat.editor.fontSize": 14,
  
  // Agent Mode 設定
  "chat.agent.enabled": true,

  // 自動接受建議設定
  "editor.inlineSuggest.enabled": true,
  "editor.inlineSuggest.showToolbar": "always"
}

┌─────────────────────────────────────────┐
│  1️⃣  Personal Instructions（個人層級）    │ ← 最高優先
│     GitHub Settings > Copilot > Personal │
├─────────────────────────────────────────┤
│  2️⃣  Repository Instructions（專案層級）  │
│     .github/copilot-instructions.md     │
│     .instructions.md（路徑特定）         │
│     AGENTS.md / CLAUDE.md / GEMINI.md    │
├─────────────────────────────────────────┤
│  3️⃣  Organization Instructions（組織層級）│ ← 最低優先
│     Organization Settings > Copilot     │
│     （需 Business / Enterprise 方案）     │
└─────────────────────────────────────────┘

# Copilot Custom Instructions

## 專案規範
- 使用 Java 21 + Spring Boot 3.x
- 遵循 Clean Architecture
- 所有回應使用繁體中文
- 程式碼註解使用 JavaDoc 格式

## 編碼規範
- 類別名稱使用 PascalCase
- 方法和變數使用 camelCase
- 常數使用 UPPER_SNAKE_CASE
- API 路徑使用 kebab-case
- 資料表名稱使用 UPPER_SNAKE_CASE

## 安全規範
- 所有輸入必須做驗證
- SQL 必須使用 Prepared Statement
- 密碼使用 bcrypt 加密
- 敏感資料不可記錄在日誌

## 測試規範
- 使用 JUnit 5 + Mockito
- 測試方法使用 @DisplayName 中文說明
- 遵循 Given-When-Then 模式

---
applyTo: "src/main/java/com/company/**/controller/**"
---

# Controller 開發規範
- 所有 Controller 方法加上 @PreAuthorize 權限檢查
- 使用 @Validated 驗證 Request DTO
- 回傳統一 ApiResponse 格式
- 加入 @Operation（OpenAPI 文件）

---
applyTo: "**/*Test.java"
---

# 測試開發規範
- 使用 @DisplayName 中文名稱
- Given-When-Then 模式
- 每個測試方法只測一個行為
- Mock 外部依賴

{
  "servers": {
    "github": {
      "command": "gh",
      "args": ["copilot", "mcp"],
      "description": "GitHub MCP Server — 存取 Issues、PRs、Repos"
    },
    "database": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://..."],
      "description": "PostgreSQL MCP Server"
    }
  }
}

{
  "servers": {
    "jira": {
      "type": "http",
      "url": "https://mcp.atlassian.com/v1/sse",
      "description": "Jira MCP — 讀取 Issue、更新狀態"
    }
  }
}

# 建立新專案
mkdir banking-web-app && cd banking-web-app

# 初始化 Git
git init
git remote add origin git@github.com:company/banking-web-app.git

# 建立 Spring Boot 專案（使用 Copilot CLI）
gh copilot suggest "create spring boot 3.3 project with maven, java 21, web, jpa, security, redis"

# 或使用 Spring Initializr
curl https://start.spring.io/starter.zip \
  -d dependencies=web,data-jpa,security,data-redis,validation,actuator \
  -d javaVersion=21 \
  -d type=maven-project \
  -d language=java \
  -d bootVersion=3.3.0 \
  -d groupId=com.company \
  -d artifactId=banking-web-app \
  -o banking-web-app.zip

<type>(<scope>): <subject>

<body>

<footer>

@workspace 請根據目前的 git diff，生成符合 Conventional Commits 規範的 commit message，使用繁體中文描述

作為 [角色]
我希望 [功能]
以便 [業務價值]

驗收條件：
- [ ] 條件 1
- [ ] 條件 2

@workspace 請根據以下需求，產出完整的 User Story（含驗收條件）：

需求：銀行客戶需要透過網路銀行進行帳戶餘額查詢，
系統需驗證客戶身分，並顯示所有帳戶的即時餘額。
需考慮安全性（MFA）、效能（2秒內回應）、可用性（99.9%）。

## US-001：帳戶餘額查詢

### User Story
作為一位已註冊的銀行客戶，
我希望能在網路銀行中查詢我所有帳戶的即時餘額，
以便即時掌握我的財務狀況。

### 驗收條件
- [ ] 客戶登入後可看到所有帳戶列表
- [ ] 每個帳戶顯示：帳號（遮罩）、帳戶類型、幣別、即時餘額
- [ ] 回應時間 ≤ 2 秒（P95）
- [ ] 需通過 MFA 二次驗證才能查看餘額
- [ ] 查詢結果不可快取於前端
- [ ] 稽核日誌需記錄：查詢人員、時間、IP、查詢帳戶

### 非功能性需求
- 效能：P95 < 2s，支援 1000 TPS
- 安全：TLS 1.3 傳輸、個資遮罩
- 可用性：99.9%

@workspace 請分析以下 User Story 的邊界條件、異常情境、安全風險：

US-001：帳戶餘額查詢
[貼上 User Story 內容]

請列出：
1. 正常流程
2. 異常流程（至少 5 個）
3. 安全風險（STRIDE 分析）
4. 效能考量

@workspace 請根據以下需求，產出系統架構設計文件（SAD）：

系統：銀行帳戶查詢服務
技術棧：Spring Boot 3.x + Redis + Oracle
架構：Clean Architecture
安全：JWT + MFA
部署：Kubernetes

請包含：
1. 系統架構圖（文字描述）
2. 元件設計
3. 資料流程
4. 安全設計
5. 效能設計

@workspace 請為帳戶餘額查詢功能設計 RESTful API，產出 OpenAPI 3.0 YAML 規格：

要求：
- 路徑：GET /api/v1/accounts/{customerId}/balances
- 需認證（Bearer JWT）
- 回應包含多帳戶餘額
- 包含分頁
- 錯誤回應格式標準化

openapi: 3.0.3
info:
  title: Account Balance API
  version: 1.0.0
  description: 帳戶餘額查詢 API

paths:
  /api/v1/accounts/{customerId}/balances:
    get:
      summary: 查詢客戶所有帳戶餘額
      operationId: getAccountBalances
      tags:
        - Account
      security:
        - bearerAuth: []
      parameters:
        - name: customerId
          in: path
          required: true
          schema:
            type: string
            pattern: '^[A-Z0-9]{10}$'
          description: 客戶 ID
        - name: page
          in: query
          schema:
            type: integer
            default: 0
        - name: size
          in: query
          schema:
            type: integer
            default: 20
            maximum: 100
      responses:
        '200':
          description: 查詢成功
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AccountBalanceResponse'
        '401':
          description: 未認證
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '403':
          description: 無權限
        '404':
          description: 客戶不存在

components:
  schemas:
    AccountBalanceResponse:
      type: object
      properties:
        success:
          type: boolean
        code:
          type: string
        data:
          type: array
          items:
            $ref: '#/components/schemas/AccountBalance'
        timestamp:
          type: string
          format: date-time
        traceId:
          type: string

    AccountBalance:
      type: object
      properties:
        accountNo:
          type: string
          description: 帳號（遮罩後）
          example: "****1234"
        accountType:
          type: string
          enum: [CHECKING, SAVINGS, FIXED_DEPOSIT]
        currency:
          type: string
          example: "TWD"
        balance:
          type: number
          format: decimal
          example: 1500000.00
        lastUpdated:
          type: string
          format: date-time

    ErrorResponse:
      type: object
      properties:
        success:
          type: boolean
          example: false
        code:
          type: string
          example: "E1001"
        message:
          type: string
        traceId:
          type: string

  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

@workspace 請為帳戶餘額查詢設計資料庫 Schema（Oracle）：

要求：
- 客戶資料表
- 帳戶資料表
- 餘額資料表
- 稽核日誌表
- 包含索引設計
- 遵循命名規範（UPPER_SNAKE_CASE）

-- 客戶資料表
CREATE TABLE CUSTOMER (
    CUSTOMER_ID         VARCHAR2(10)    PRIMARY KEY,
    CUSTOMER_NAME       VARCHAR2(100)   NOT NULL,
    ID_NUMBER           VARCHAR2(64)    NOT NULL,  -- 加密儲存
    EMAIL               VARCHAR2(200),
    PHONE               VARCHAR2(20),
    STATUS              VARCHAR2(10)    DEFAULT 'ACTIVE' NOT NULL,
    CREATED_AT          TIMESTAMP       DEFAULT CURRENT_TIMESTAMP NOT NULL,
    UPDATED_AT          TIMESTAMP,
    CREATED_BY          VARCHAR2(50)    NOT NULL,
    UPDATED_BY          VARCHAR2(50)
);

-- 帳戶資料表
CREATE TABLE ACCOUNT (
    ACCOUNT_ID          NUMBER          GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    ACCOUNT_NO          VARCHAR2(20)    NOT NULL UNIQUE,
    CUSTOMER_ID         VARCHAR2(10)    NOT NULL,
    ACCOUNT_TYPE        VARCHAR2(20)    NOT NULL,  -- CHECKING, SAVINGS, FIXED_DEPOSIT
    CURRENCY            VARCHAR2(3)     DEFAULT 'TWD' NOT NULL,
    STATUS              VARCHAR2(10)    DEFAULT 'ACTIVE' NOT NULL,
    OPENED_AT           TIMESTAMP       NOT NULL,
    CLOSED_AT           TIMESTAMP,
    CREATED_AT          TIMESTAMP       DEFAULT CURRENT_TIMESTAMP NOT NULL,
    CONSTRAINT FK_ACCOUNT_CUSTOMER FOREIGN KEY (CUSTOMER_ID)
        REFERENCES CUSTOMER(CUSTOMER_ID)
);

-- 餘額資料表
CREATE TABLE ACCOUNT_BALANCE (
    BALANCE_ID          NUMBER          GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    ACCOUNT_ID          NUMBER          NOT NULL,
    AVAILABLE_BALANCE   NUMBER(18,2)    NOT NULL,
    LEDGER_BALANCE      NUMBER(18,2)    NOT NULL,
    HOLD_AMOUNT         NUMBER(18,2)    DEFAULT 0,
    LAST_UPDATED        TIMESTAMP       NOT NULL,
    CONSTRAINT FK_BALANCE_ACCOUNT FOREIGN KEY (ACCOUNT_ID)
        REFERENCES ACCOUNT(ACCOUNT_ID)
);

-- 稽核日誌表
CREATE TABLE AUDIT_LOG (
    AUDIT_ID            NUMBER          GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    EVENT_TIME          TIMESTAMP       DEFAULT CURRENT_TIMESTAMP NOT NULL,
    USER_ID             VARCHAR2(50)    NOT NULL,
    CLIENT_IP           VARCHAR2(45),
    ACTION              VARCHAR2(50)    NOT NULL,
    RESOURCE_TYPE       VARCHAR2(50)    NOT NULL,
    RESOURCE_ID         VARCHAR2(100),
    DESCRIPTION         VARCHAR2(2000),
    RESPONSE_STATUS     VARCHAR2(20),
    TRACE_ID            VARCHAR2(100)
);

-- 索引設計
CREATE INDEX IDX_ACCOUNT_CUSTOMER_ID ON ACCOUNT(CUSTOMER_ID);
CREATE INDEX IDX_ACCOUNT_STATUS ON ACCOUNT(STATUS);
CREATE INDEX IDX_BALANCE_ACCOUNT_ID ON ACCOUNT_BALANCE(ACCOUNT_ID);
CREATE INDEX IDX_AUDIT_EVENT_TIME ON AUDIT_LOG(EVENT_TIME);
CREATE INDEX IDX_AUDIT_USER_ID ON AUDIT_LOG(USER_ID);
CREATE INDEX IDX_AUDIT_TRACE_ID ON AUDIT_LOG(TRACE_ID);

@workspace 請根據 OpenAPI spec 產生 AccountController，遵循以下規範：
- Clean Architecture
- 使用 Jakarta Validation
- 統一回應格式 ApiResponse<T>
- 包含稽核日誌 AOP
- 包含 Swagger 註解

package com.company.banking.controller;

import com.company.banking.application.service.AccountApplicationService;
import com.company.banking.common.response.ApiResponse;
import com.company.banking.controller.dto.response.AccountBalanceResponse;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.constraints.Pattern;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

/**
 * 帳戶餘額查詢 Controller
 *
 * @author 開發團隊
 * @since 1.0.0
 */
@RestController
@RequestMapping("/api/v1/accounts")
@RequiredArgsConstructor
@Validated
@Slf4j
@Tag(name = "Account", description = "帳戶相關 API")
public class AccountController {

    private final AccountApplicationService accountService;

    /**
     * 查詢客戶所有帳戶餘額
     *
     * @param customerId 客戶 ID
     * @param pageable   分頁參數
     * @return 帳戶餘額列表
     */
    @GetMapping("/{customerId}/balances")
    @Operation(summary = "查詢客戶帳戶餘額", description = "查詢指定客戶的所有帳戶即時餘額")
    @PreAuthorize("hasAuthority('ACCOUNT_READ') and #customerId == authentication.principal.customerId")
    @Auditable(action = AuditAction.READ, resourceType = "ACCOUNT_BALANCE")
    public ResponseEntity<ApiResponse<Page<AccountBalanceResponse>>> getBalances(
            @PathVariable
            @Pattern(regexp = "^[A-Z0-9]{10}$", message = "客戶 ID 格式不正確")
            String customerId,
            Pageable pageable) {

        log.info("查詢帳戶餘額: customerId={}", customerId);

        Page<AccountBalanceResponse> balances = accountService.getAccountBalances(customerId, pageable);

        return ResponseEntity.ok(ApiResponse.success(balances));
    }
}

@workspace 請產生 AccountApplicationService，實作帳戶餘額查詢邏輯：
- 先從 Redis Cache 查詢
- Cache Miss 時從 Oracle DB 查詢
- 結果寫回 Cache（TTL 5 分鐘）
- 帳號遮罩處理
- 異常處理

package com.company.banking.application.service;

import com.company.banking.controller.dto.response.AccountBalanceResponse;
import com.company.banking.domain.exception.CustomerNotFoundException;
import com.company.banking.domain.model.Account;
import com.company.banking.domain.repository.AccountRepository;
import com.company.banking.domain.repository.CustomerRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * 帳戶應用服務
 *
 * <p>處理帳戶相關的業務流程編排，包含快取策略與資料轉換。</p>
 *
 * @author 開發團隊
 * @since 1.0.0
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class AccountApplicationService {

    private final AccountRepository accountRepository;
    private final CustomerRepository customerRepository;

    /**
     * 查詢客戶所有帳戶餘額
     *
     * @param customerId 客戶 ID
     * @param pageable   分頁參數
     * @return 帳戶餘額列表（分頁）
     * @throws CustomerNotFoundException 當客戶不存在時拋出
     */
    @Transactional(readOnly = true)
    @Cacheable(value = "accountBalances", key = "#customerId + '_' + #pageable.pageNumber",
               unless = "#result.isEmpty()")
    public Page<AccountBalanceResponse> getAccountBalances(String customerId, Pageable pageable) {
        // 1. 驗證客戶是否存在
        if (!customerRepository.existsById(customerId)) {
            throw new CustomerNotFoundException(customerId);
        }

        // 2. 查詢帳戶餘額
        Page<Account> accounts = accountRepository.findActiveAccountsByCustomerId(customerId, pageable);

        // 3. 轉換並遮罩
        return accounts.map(this::toBalanceResponse);
    }

    private AccountBalanceResponse toBalanceResponse(Account account) {
        return AccountBalanceResponse.builder()
                .accountNo(maskAccountNo(account.getAccountNo()))
                .accountType(account.getAccountType().name())
                .currency(account.getCurrency())
                .balance(account.getBalance().getAvailableBalance())
                .lastUpdated(account.getBalance().getLastUpdated())
                .build();
    }

    /**
     * 帳號遮罩：僅顯示後 4 碼
     */
    private String maskAccountNo(String accountNo) {
        if (accountNo == null || accountNo.length() <= 4) {
            return "****";
        }
        return "****" + accountNo.substring(accountNo.length() - 4);
    }
}

@workspace 請產生 AccountRepository 介面（Domain Layer）和 AccountRepositoryImpl 實作（Infrastructure Layer），
使用 Spring Data JPA，包含 Custom Query。

@workspace 請用 Vue 3 + TypeScript + Composition API 產生帳戶餘額查詢頁面：
- 使用 Tailwind CSS 樣式
- 呼叫 GET /api/v1/accounts/{customerId}/balances
- 包含 Loading 狀態
- 錯誤處理
- 餘額金額格式化

<script setup lang="ts">
import { ref, onMounted } from 'vue'

interface AccountBalance {
  accountNo: string
  accountType: string
  currency: string
  balance: number
  lastUpdated: string
}

interface ApiResponse<T> {
  success: boolean
  code: string
  data: T
  message?: string
}

const balances = ref<AccountBalance[]>([])
const loading = ref(false)
const error = ref<string | null>(null)

const fetchBalances = async () => {
  loading.value = true
  error.value = null

  try {
    const response = await fetch('/api/v1/accounts/me/balances', {
      headers: {
        'Authorization': `Bearer ${getToken()}`,
        'Content-Type': 'application/json'
      }
    })

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`)
    }

    const result: ApiResponse<{ content: AccountBalance[] }> = await response.json()

    if (result.success) {
      balances.value = result.data.content
    } else {
      error.value = result.message || '查詢失敗'
    }
  } catch (e) {
    error.value = '系統異常，請稍後再試'
    console.error('查詢帳戶餘額失敗:', e)
  } finally {
    loading.value = false
  }
}

const formatCurrency = (amount: number, currency: string): string => {
  return new Intl.NumberFormat('zh-TW', {
    style: 'currency',
    currency: currency
  }).format(amount)
}

const getAccountTypeLabel = (type: string): string => {
  const labels: Record<string, string> = {
    CHECKING: '活期存款',
    SAVINGS: '儲蓄存款',
    FIXED_DEPOSIT: '定期存款'
  }
  return labels[type] || type
}

const getToken = (): string => {
  return sessionStorage.getItem('accessToken') || ''
}

onMounted(fetchBalances)
</script>

<template>
  <div class="max-w-4xl mx-auto p-6">
    <h1 class="text-2xl font-bold text-gray-800 mb-6">帳戶餘額查詢</h1>

    <!-- Loading -->
    <div v-if="loading" class="flex justify-center py-12">
      <div class="animate-spin rounded-full h-10 w-10 border-b-2 border-blue-600"></div>
    </div>

    <!-- Error -->
    <div v-else-if="error" class="bg-red-50 border border-red-200 rounded-lg p-4 text-red-700">
      {{ error }}
      <button @click="fetchBalances" class="ml-4 text-red-600 underline">重試</button>
    </div>

    <!-- Balance List -->
    <div v-else class="space-y-4">
      <div
        v-for="account in balances"
        :key="account.accountNo"
        class="bg-white rounded-lg shadow-md p-6 border border-gray-100
               hover:shadow-lg transition-shadow"
      >
        <div class="flex justify-between items-center">
          <div>
            <p class="text-sm text-gray-500">{{ getAccountTypeLabel(account.accountType) }}</p>
            <p class="text-lg font-mono text-gray-700">{{ account.accountNo }}</p>
          </div>
          <div class="text-right">
            <p class="text-2xl font-bold text-gray-900">
              {{ formatCurrency(account.balance, account.currency) }}
            </p>
            <p class="text-xs text-gray-400">
              更新時間：{{ new Date(account.lastUpdated).toLocaleString('zh-TW') }}
            </p>
          </div>
        </div>
      </div>

      <div v-if="balances.length === 0" class="text-center py-12 text-gray-400">
        目前沒有帳戶資料
      </div>
    </div>
  </div>
</template>

@workspace 請為 AccountApplicationService.getAccountBalances 方法生成完整的 JUnit 5 測試：
- 使用 Mockito
- 使用 @DisplayName 中文說明
- 遵循 Given-When-Then 模式
- 包含：正常情境、客戶不存在、空結果、異常處理

package com.company.banking.application.service;

import com.company.banking.controller.dto.response.AccountBalanceResponse;
import com.company.banking.domain.exception.CustomerNotFoundException;
import com.company.banking.domain.model.Account;
import com.company.banking.domain.model.AccountBalance;
import com.company.banking.domain.model.AccountType;
import com.company.banking.domain.repository.AccountRepository;
import com.company.banking.domain.repository.CustomerRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;

import static org.assertj.core.api.Assertions.*;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
@DisplayName("帳戶應用服務測試")
class AccountApplicationServiceTest {

    @Mock
    private AccountRepository accountRepository;

    @Mock
    private CustomerRepository customerRepository;

    @InjectMocks
    private AccountApplicationService service;

    private static final String CUSTOMER_ID = "CUST000001";
    private static final Pageable PAGEABLE = PageRequest.of(0, 20);

    @Nested
    @DisplayName("查詢帳戶餘額")
    class GetAccountBalancesTests {

        @Test
        @DisplayName("客戶存在且有帳戶時，應返回餘額列表")
        void shouldReturnBalances_WhenCustomerExistsAndHasAccounts() {
            // Given
            when(customerRepository.existsById(CUSTOMER_ID)).thenReturn(true);

            Account account = createTestAccount("1234567890", AccountType.CHECKING,
                    new BigDecimal("1500000.00"));
            Page<Account> accountPage = new PageImpl<>(List.of(account));
            when(accountRepository.findActiveAccountsByCustomerId(CUSTOMER_ID, PAGEABLE))
                    .thenReturn(accountPage);

            // When
            Page<AccountBalanceResponse> result = service.getAccountBalances(CUSTOMER_ID, PAGEABLE);

            // Then
            assertThat(result.getContent()).hasSize(1);
            assertThat(result.getContent().get(0).getAccountNo()).isEqualTo("****7890");
            assertThat(result.getContent().get(0).getBalance())
                    .isEqualByComparingTo(new BigDecimal("1500000.00"));

            verify(customerRepository).existsById(CUSTOMER_ID);
            verify(accountRepository).findActiveAccountsByCustomerId(CUSTOMER_ID, PAGEABLE);
        }

        @Test
        @DisplayName("客戶不存在時，應拋出 CustomerNotFoundException")
        void shouldThrowException_WhenCustomerNotFound() {
            // Given
            when(customerRepository.existsById(CUSTOMER_ID)).thenReturn(false);

            // When & Then
            assertThatThrownBy(() -> service.getAccountBalances(CUSTOMER_ID, PAGEABLE))
                    .isInstanceOf(CustomerNotFoundException.class)
                    .hasMessageContaining(CUSTOMER_ID);

            verify(accountRepository, never()).findActiveAccountsByCustomerId(any(), any());
        }

        @Test
        @DisplayName("客戶存在但無帳戶時，應返回空列表")
        void shouldReturnEmpty_WhenCustomerHasNoAccounts() {
            // Given
            when(customerRepository.existsById(CUSTOMER_ID)).thenReturn(true);
            when(accountRepository.findActiveAccountsByCustomerId(CUSTOMER_ID, PAGEABLE))
                    .thenReturn(Page.empty());

            // When
            Page<AccountBalanceResponse> result = service.getAccountBalances(CUSTOMER_ID, PAGEABLE);

            // Then
            assertThat(result.getContent()).isEmpty();
        }

        @Test
        @DisplayName("帳號遮罩應正確處理")
        void shouldMaskAccountNumber() {
            // Given
            when(customerRepository.existsById(CUSTOMER_ID)).thenReturn(true);

            Account account = createTestAccount("9876543210", AccountType.SAVINGS,
                    new BigDecimal("500000.00"));
            when(accountRepository.findActiveAccountsByCustomerId(CUSTOMER_ID, PAGEABLE))
                    .thenReturn(new PageImpl<>(List.of(account)));

            // When
            Page<AccountBalanceResponse> result = service.getAccountBalances(CUSTOMER_ID, PAGEABLE);

            // Then
            assertThat(result.getContent().get(0).getAccountNo()).isEqualTo("****3210");
        }
    }

    private Account createTestAccount(String accountNo, AccountType type, BigDecimal balance) {
        return Account.builder()
                .accountNo(accountNo)
                .accountType(type)
                .currency("TWD")
                .balance(AccountBalance.builder()
                        .availableBalance(balance)
                        .lastUpdated(LocalDateTime.now())
                        .build())
                .build();
    }
}

@workspace 請為 AccountController 產生整合測試，使用 @SpringBootTest + MockMvc，
測試 API 回應格式、HTTP Status、認證檢查。

@workspace 請用 Playwright (TypeScript) 撰寫帳戶餘額查詢的 E2E 測試：
- 測試登入 → 查詢餘額 → 驗證顯示結果
- 測試未登入時應被導向登入頁
- 測試錯誤情境

import { test, expect } from '@playwright/test';

test.describe('帳戶餘額查詢', () => {
  test.beforeEach(async ({ page }) => {
    // 登入
    await page.goto('/login');
    await page.fill('[data-testid="username"]', 'testuser');
    await page.fill('[data-testid="password"]', 'TestPass123!');
    await page.click('[data-testid="login-btn"]');
    await page.waitForURL('/dashboard');
  });

  test('應顯示帳戶餘額列表', async ({ page }) => {
    await page.goto('/accounts/balances');

    // 等待資料載入
    await page.waitForSelector('[data-testid="balance-card"]');

    // 驗證帳戶卡片存在
    const cards = page.locator('[data-testid="balance-card"]');
    await expect(cards).toHaveCount(await cards.count());

    // 驗證帳號遮罩
    const accountNo = page.locator('[data-testid="account-no"]').first();
    await expect(accountNo).toHaveText(/^\*{4}\d{4}$/);

    // 驗證金額格式
    const balance = page.locator('[data-testid="balance-amount"]').first();
    await expect(balance).toContainText('$');
  });

  test('未登入應導向登入頁', async ({ page }) => {
    // 清除 Session
    await page.context().clearCookies();
    await page.goto('/accounts/balances');
    await expect(page).toHaveURL(/\/login/);
  });
});

@workspace 分析 #file:AccountApplicationService.java 的測試覆蓋率缺口，
列出尚未覆蓋的分支與邊界條件，並生成對應的測試案例。

@workspace 請檢查 #file:SecurityConfig.java 是否有安全問題，並提供修正版本：
- CORS 設定是否過於寬鬆
- CSRF 是否正確處理
- Session 管理是否安全
- HTTP Headers 安全設定

# .github/workflows/security-scan.yml
name: Security Scan

on:
  pull_request:
    branches: [main, develop]

jobs:
  codeql:
    name: CodeQL Analysis
    runs-on: ubuntu-latest
    permissions:
      security-events: write
    steps:
      - uses: actions/checkout@v4
      - uses: github/codeql-action/init@v3
        with:
          languages: java
      - uses: github/codeql-action/autobuild@v3
      - uses: github/codeql-action/analyze@v3

  dependency-review:
    name: Dependency Review
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/dependency-review-action@v4
        with:
          fail-on-severity: high
          deny-licenses: GPL-3.0

  copilot-review:
    name: Copilot Code Review
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      # Copilot Code Review 自動觸發於 PR

# .github/workflows/ci-cd.yml
name: CI/CD Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main, develop]

env:
  JAVA_VERSION: '21'
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  # ===== 建置與測試 =====
  build:
    name: Build & Test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: 'temurin'
          cache: maven

      - name: Build
        run: mvn clean compile -B

      - name: Unit Tests
        run: mvn test -B

      - name: Integration Tests
        run: mvn verify -B -Pintegration-test

      - name: Upload Test Results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: test-results
          path: target/surefire-reports/

  # ===== 程式碼品質 =====
  quality:
    name: Code Quality
    runs-on: ubuntu-latest
    needs: build
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: 'temurin'
          cache: maven

      - name: SonarQube Scan
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
        run: |
          mvn sonar:sonar \
            -Dsonar.projectKey=${{ github.event.repository.name }} \
            -Dsonar.host.url=${{ secrets.SONAR_HOST_URL }} \
            -Dsonar.qualitygate.wait=true

  # ===== 安全掃描 =====
  security:
    name: Security Scan
    runs-on: ubuntu-latest
    needs: build
    steps:
      - uses: actions/checkout@v4

      - name: OWASP Dependency Check
        uses: dependency-check/Dependency-Check_Action@main
        with:
          project: ${{ github.event.repository.name }}
          path: '.'
          format: 'HTML'
          args: '--failOnCVSS 7'

      - name: Upload Security Report
        uses: actions/upload-artifact@v4
        with:
          name: dependency-check-report
          path: reports/

  # ===== 部署至 DEV =====
  deploy-dev:
    name: Deploy to DEV
    runs-on: ubuntu-latest
    needs: [build, quality, security]
    if: github.ref == 'refs/heads/develop'
    environment: development
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: 'temurin'
          cache: maven

      - name: Package
        run: mvn package -DskipTests -B

      - name: Build & Push Docker Image
        run: |
          echo ${{ secrets.GITHUB_TOKEN }} | docker login ghcr.io -u ${{ github.actor }} --password-stdin
          docker build -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:dev-${{ github.sha }} .
          docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:dev-${{ github.sha }}

      - name: Deploy to Kubernetes
        run: |
          kubectl set image deployment/banking-app \
            banking-app=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:dev-${{ github.sha }} \
            --namespace=development

  # ===== 部署至 PROD（需人工審核） =====
  deploy-prod:
    name: Deploy to Production
    runs-on: ubuntu-latest
    needs: [build, quality, security]
    if: github.ref == 'refs/heads/main'
    environment: production  # 需 Reviewer 核准
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: 'temurin'
          cache: maven

      - name: Package
        run: mvn package -DskipTests -B

      - name: Build & Push Docker Image
        run: |
          echo ${{ secrets.GITHUB_TOKEN }} | docker login ghcr.io -u ${{ github.actor }} --password-stdin
          docker build -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }} .
          docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }}

      - name: Deploy to Kubernetes (Blue-Green)
        run: |
          # Blue-Green 部署腳本
          kubectl apply -f k8s/production/deployment-green.yaml
          kubectl rollout status deployment/banking-app-green -n production --timeout=300s
          kubectl apply -f k8s/production/service-switch-green.yaml

# 多階段建置
FROM eclipse-temurin:21-jre-alpine AS runtime

# 安全設定
RUN addgroup -g 1001 appgroup && \
    adduser -u 1001 -G appgroup -D appuser

WORKDIR /app

COPY target/*.jar app.jar

# 安全：以非 root 執行
USER appuser

# 健康檢查
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD wget -qO- http://localhost:8080/actuator/health || exit 1

EXPOSE 8080

ENTRYPOINT ["java", \
  "-XX:+UseG1GC", \
  "-XX:MaxRAMPercentage=75.0", \
  "-Djava.security.egd=file:/dev/./urandom", \
  "-jar", "app.jar"]

# application-prd.yml
logging:
  level:
    root: INFO
    com.company.banking: INFO
    org.springframework.security: WARN
  pattern:
    console: '{"timestamp":"%d{ISO8601}","level":"%level","logger":"%logger","traceId":"%X{traceId}","message":"%msg"}%n'

@workspace 以下是系統日誌片段，請分析可能的問題原因並建議修復方案：

[貼上日誌內容]

請提供：
1. 問題根因分析
2. 影響範圍評估
3. 修復建議（含程式碼）
4. 預防措施

management:
  endpoints:
    web:
      exposure:
        include: health,info,prometheus,metrics
  endpoint:
    health:
      show-details: when_authorized
  metrics:
    export:
      prometheus:
        enabled: true
    tags:
      application: banking-app

@Component
@RequiredArgsConstructor
public class BusinessMetrics {

    private final MeterRegistry meterRegistry;

    public void recordBalanceQuery(String customerId, long durationMs) {
        meterRegistry.timer("business.balance.query")
                .record(durationMs, TimeUnit.MILLISECONDS);

        meterRegistry.counter("business.balance.query.count").increment();
    }

    public void recordQueryError(String errorType) {
        meterRegistry.counter("business.balance.query.error",
                "type", errorType).increment();
    }
}

groups:
  - name: banking-app-alerts
    rules:
      - alert: HighErrorRate
        expr: |
          sum(rate(http_server_requests_seconds_count{status=~"5.."}[5m]))
          / sum(rate(http_server_requests_seconds_count[5m])) > 0.05
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "銀行應用系統錯誤率過高"
          description: "錯誤率 {{ $value | humanizePercentage }}"

      - alert: HighLatency
        expr: |
          histogram_quantile(0.95,
            sum(rate(http_server_requests_seconds_bucket[5m])) by (le)
          ) > 2
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "API 回應時間過長（P95 > 2s）"

      - alert: BalanceQueryFailure
        expr: |
          rate(business_balance_query_error_total[5m]) > 10
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "帳戶餘額查詢失敗率異常"

@workspace 系統出現以下告警，請協助診斷：

告警：HighLatency - P95 回應時間 3.5 秒
時間：2026-04-15 14:30
影響範圍：/api/v1/accounts/*/balances

相關日誌：
[貼上日誌]

請提供：
1. 可能的根因
2. 診斷步驟
3. 緊急修復方案
4. 長期改善建議

角色：你是一位熟悉銀行業務的 Spring Boot 資深工程師
上下文：
- 專案使用 Clean Architecture
- 使用 Java 21 + Spring Boot 3.3
- 資料庫使用 Oracle
- 需遵循 OWASP Top 10 安全規範

任務：請根據以下需求產生 [Service/Controller/Repository]

需求：[具體業務需求]

約束：
- 使用 Jakarta Validation 驗證輸入
- 使用 @Transactional 管理交易
- 包含完整的異常處理
- 日誌不可記錄敏感資訊
- 帳號需遮罩處理

輸出格式：完整的 Java 程式碼，包含 JavaDoc 註解

請對以下程式碼進行安全審查：

#file:[檔案路徑]

請檢查：
1. SQL Injection 風險
2. XSS 風險
3. 認證/授權漏洞
4. 敏感資訊洩露
5. 輸入驗證不足
6. CSRF 防護
7. Session 管理

對每個發現的問題，請提供：
- 風險等級（Critical/High/Medium/Low）
- 問題描述
- 修復程式碼

@workspace 請分析以下程式碼的效能瓶頸，並提供優化建議：

#file:[檔案路徑]

考量因素：
- 資料庫查詢效能
- 快取策略
- 併發處理
- 記憶體使用

請提供：
1. 效能問題清單
2. 優化後的程式碼
3. 預期效能提升

# 專案架構規範

## 技術棧
- Java 21 + Spring Boot 3.3
- Oracle 19c / PostgreSQL 15
- Redis 7
- Vue 3 + TypeScript + Tailwind CSS

## 架構規範
- 遵循 Clean Architecture
- Controller → Application Service → Domain Service → Repository
- Domain Layer 不可依賴 Infrastructure Layer

## 命名規範
- Controller 類別：XxxController
- Application Service：XxxApplicationService
- Domain Service：XxxDomainService
- Repository 介面：XxxRepository（Domain Layer）
- Repository 實作：XxxRepositoryImpl（Infrastructure Layer）
- DTO：XxxRequest / XxxResponse

## 安全規範
- 所有 API 需驗證 JWT Token
- 敏感操作需記錄稽核日誌
- 輸入必須驗證（使用 Jakarta Validation）
- SQL 使用 Prepared Statement
- 密碼使用 BCrypt 加密
- 日誌禁止記錄敏感資訊

## 測試規範
- 使用 JUnit 5 + Mockito
- 測試方法使用 @DisplayName 中文名稱
- 遵循 Given-When-Then 模式
- 核心業務邏輯測試覆蓋率 ≥ 80%

## 回應語言
- 使用繁體中文回覆
- 程式碼註解使用 JavaDoc 格式

---
mode: "agent"
tools: ["semantic_search", "run_in_terminal", "read_file"]
description: "執行 OWASP Top 10 安全審查"
---

請對 #file:${input:file} 進行 OWASP Top 10 安全審查。

請檢查：
1. SQL Injection
2. XSS
3. Broken Authentication
4. Sensitive Data Exposure
5. Security Misconfiguration

每個發現的問題請列出：
- 嚴重度（Critical / High / Medium / Low）
- 程式碼位置
- 修復建議程式碼

.github/prompts/
├── dev/
│   ├── create-controller.prompt.md
│   ├── create-service.prompt.md
│   └── create-repository.prompt.md
├── test/
│   ├── unit-test.prompt.md
│   └── integration-test.prompt.md
├── review/
│   ├── security-review.prompt.md
│   ├── performance-review.prompt.md
│   └── code-quality.prompt.md
└── ops/
    ├── create-pipeline.prompt.md
    └── create-dockerfile.prompt.md

請為「客戶管理」功能建立完整的 Clean Architecture 結構：

1. Controller: CustomerController.java
2. DTO: CreateCustomerRequest.java, CustomerResponse.java
3. Application Service: CustomerApplicationService.java
4. Domain Model: Customer.java
5. Domain Repository: CustomerRepository.java (介面)
6. Infrastructure Repository: CustomerRepositoryImpl.java
7. Entity: CustomerEntity.java
8. Mapper: CustomerMapper.java
9. Exception: CustomerNotFoundException.java
10. Unit Test: CustomerApplicationServiceTest.java

每個檔案請遵循專案規範。

@workspace 請重構 #file:LegacyPaymentService.java：

目前問題：
1. 方法過長（> 100 行）
2. 職責不單一
3. 缺少介面抽象
4. 硬編碼常數

目標：
1. 拆分為多個小方法
2. 抽出介面
3. 常數移至設定檔
4. 加入錯誤處理
5. 不改變外部行為

請先提供重構計畫，再逐步實作。

# .github/copilot-code-review.yml（如適用）
review:
  auto_review: true
  languages:
    - java
    - typescript
    - yaml
  focus_areas:
    - security
    - performance
    - best_practices

<!-- .github/copilot/agents/security-reviewer.md -->
---
name: "security-reviewer"
description: "專責安全審查的 AI 代理"
tools: ["read_file", "grep_search", "semantic_search"]
---

你是一位資深資安工程師。對每次程式碼變更執行以下檢查：
1. OWASP Top 10 弱點掃描
2. 敏感資料洩漏檢查
3. 認證授權邏輯驗證
4. 輸入驗證完整性確認

回報格式：
- 風險等級：Critical / High / Medium / Low
- 問題描述
- 影響範圍
- 修復建議

// .github/copilot/hooks.json
{
  "pre-commit": {
    "command": "mvn spotless:check && mvn checkstyle:check",
    "description": "提交前檢查程式碼格式"
  },
  "post-push": {
    "command": "mvn verify -P security-scan",
    "description": "推送後執行安全掃描"
  }
}

請根據附件的 UI 設計稿（Figma 截圖），使用 Vue 3 + Tailwind CSS 實作此頁面。
[附加圖片]

prompts/
├── v1/
│   ├── controller-generation.md
│   ├── test-generation.md
│   └── security-review.md
├── v2/
│   ├── controller-generation.md    # 改進版
│   ├── test-generation.md
│   └── security-review.md
└── changelog.md

## Prompt 優化記錄

### controller-generation.md
| 版本 | 日期 | 變更 | 效果 |
|------|------|------|------|
| v1.0 | 2026-03-01 | 初版 | 基本功能可用 |
| v1.1 | 2026-03-15 | 新增安全約束 | 生成的程式碼包含權限檢查 |
| v2.0 | 2026-04-01 | 加入架構範例參照 | 一致性提升 90% |

.github/
├── copilot-instructions.md          # 全域 Copilot 指引
├── docs/
│   ├── architecture/
│   │   ├── system-architecture.md   # 系統架構文件
│   │   ├── api-design-guide.md      # API 設計指南
│   │   └── database-guide.md        # 資料庫設計指南
│   ├── security/
│   │   ├── security-policy.md       # 安全政策
│   │   ├── owasp-checklist.md       # OWASP 清單
│   │   └── secure-coding.md         # 安全編碼指南
│   ├── operations/
│   │   ├── runbook.md               # 維運手冊
│   │   └── incident-response.md     # 事件處理流程
│   └── patterns/
│       ├── best-practices.md        # 最佳實務
│       ├── anti-patterns.md         # 反模式
│       └── lessons-learned.md       # 經驗教訓
└── prompts/
    ├── development/
    ├── testing/
    └── review/

@workspace 請根據 src/main/java/com/company/banking/controller/ 目錄下的所有 Controller，
自動產生完整的 API 文件（Markdown 格式），包含：
1. API 端點清單
2. 請求/回應格式
3. 認證要求
4. 錯誤碼說明
5. 使用範例（curl）

@workspace 請根據 git log 最近 10 個 commit，產生 CHANGELOG.md 更新，
遵循 Keep a Changelog 格式，分類為 Added / Changed / Fixed / Security。

@workspace 請幫我規劃「網路銀行帳戶查詢」功能的 User Story 和 API 設計：
- 客戶登入後查詢所有帳戶餘額
- 支援 TWD、USD、CNY 多幣別
- 需要 MFA 驗證
- 回應時間 < 2 秒

請根據 Clean Architecture 建立完整的專案結構，包含 Controller、Service、Repository、Entity、DTO

請為帳戶查詢功能產生完整的後端程式碼

請為產出的程式碼生成 Unit Test 和 Integration Test

請對產出的程式碼進行 OWASP Top 10 安全檢查

@workspace 請產生安全的 SFTP 檔案上傳 Service：
- 使用 JSch 或 Apache Commons VFS
- 支援 SFTP（SSH Key 認證）
- 檔案大小限制 100MB
- 包含 checksum 驗證
- 上傳前掃描病毒（ClamAV）
- 完整的稽核日誌
- 失敗重試機制（最多 3 次）

@Service
@Slf4j
@RequiredArgsConstructor
public class SftpUploadService {

    private final SftpConnectionFactory connectionFactory;
    private final FileValidator fileValidator;
    private final AuditLogService auditLog;

    @Value("${sftp.max-file-size:104857600}")  // 100MB
    private long maxFileSize;

    @Value("${sftp.max-retry:3}")
    private int maxRetry;

    /**
     * 安全上傳檔案至 SFTP 伺服器
     *
     * @param file     上傳的檔案
     * @param remotePath 遠端路徑
     * @return 上傳結果
     */
    @Retryable(maxAttempts = 3, backoff = @Backoff(delay = 2000, multiplier = 2))
    public UploadResult uploadFile(MultipartFile file, String remotePath) {
        // 1. 驗證檔案
        fileValidator.validate(file, maxFileSize);

        // 2. 計算 Checksum
        String checksum = DigestUtils.sha256Hex(file.getInputStream());
        log.info("檔案上傳開始: name={}, size={}, checksum={}",
                file.getOriginalFilename(), file.getSize(), checksum);

        // 3. SFTP 上傳
        try (SftpConnection conn = connectionFactory.getConnection()) {
            conn.upload(file.getInputStream(), remotePath);

            // 4. 驗證上傳結果
            String remoteChecksum = conn.getRemoteChecksum(remotePath);
            if (!checksum.equals(remoteChecksum)) {
                throw new FileIntegrityException("Checksum 不一致");
            }

            // 5. 稽核日誌
            auditLog.log(AuditAction.FILE_UPLOAD, "SFTP",
                    Map.of("fileName", file.getOriginalFilename(),
                           "remotePath", remotePath,
                           "checksum", checksum,
                           "size", file.getSize()));

            return UploadResult.success(remotePath, checksum);

        } catch (Exception e) {
            log.error("SFTP 上傳失敗: {}", e.getMessage());
            auditLog.log(AuditAction.FILE_UPLOAD_FAILED, "SFTP",
                    Map.of("error", e.getMessage()));
            throw new SftpUploadException("檔案上傳失敗", e);
        }
    }
}

@workspace 請建立一個通用的資料驗證框架：
- 使用 Chain of Responsibility 模式
- 支援多規則組合
- 支援自訂錯誤訊息
- 支援 i18n
- 包含常見驗證規則：身分證字號、統一編號、手機號、Email

/**
 * 驗證規則介面
 */
public interface ValidationRule<T> {
    ValidationResult validate(T value, String fieldName);
}

/**
 * 身分證字號驗證
 */
public class TwIdNumberRule implements ValidationRule<String> {

    private static final Pattern ID_PATTERN = Pattern.compile("^[A-Z][12]\\d{8}$");

    @Override
    public ValidationResult validate(String value, String fieldName) {
        if (value == null || !ID_PATTERN.matcher(value).matches()) {
            return ValidationResult.fail(fieldName, "身分證字號格式不正確");
        }
        if (!verifyCheckDigit(value)) {
            return ValidationResult.fail(fieldName, "身分證字號檢查碼不正確");
        }
        return ValidationResult.success();
    }

    private boolean verifyCheckDigit(String id) {
        // 身分證字號驗證演算法
        int[] mapping = new int[26];
        mapping['A' - 'A'] = 10; mapping['B' - 'A'] = 11;
        // ... 完整映射
        int sum = mapping[id.charAt(0) - 'A'] / 10
                + (mapping[id.charAt(0) - 'A'] % 10) * 9;
        for (int i = 1; i < 9; i++) {
            sum += (id.charAt(i) - '0') * (9 - i);
        }
        sum += id.charAt(9) - '0';
        return sum % 10 == 0;
    }
}

/**
 * 驗證器（組合多規則）
 */
public class Validator<T> {
    private final List<ValidationRule<T>> rules = new ArrayList<>();

    public Validator<T> addRule(ValidationRule<T> rule) {
        rules.add(rule);
        return this;
    }

    public List<ValidationResult> validateAll(T value, String fieldName) {
        return rules.stream()
                .map(rule -> rule.validate(value, fieldName))
                .filter(result -> !result.isValid())
                .collect(Collectors.toList());
    }
}

- [ ] 閱讀新版本 Release Notes
- [ ] 檢查 Custom Instructions 相容性
- [ ] 確認 MCP Server 設定是否需更新
- [ ] 測試 Agent Mode 功能
- [ ] 驗證 Code Review 功能
- [ ] 更新團隊內部文件
- [ ] 通知團隊成員升級

// .vscode/extensions.json - 推薦擴充套件
{
  "recommendations": [
    "GitHub.copilot",
    "GitHub.copilot-chat",
    "vscjava.vscode-java-pack",
    "vmware.vscode-spring-boot",
    "Vue.volar",
    "bradlc.vscode-tailwindcss",
    "eamodio.gitlens",
    "SonarSource.sonarlint-vscode",
    "ms-azuretools.vscode-docker"
  ],
  "unwantedRecommendations": []
}

@workspace 請掃描專案程式碼，識別技術債：

請檢查：
1. 重複的程式碼（DRY 違規）
2. 過長的方法（> 50 行）
3. 過深的巢狀（> 3 層）
4. TODO / FIXME / HACK 標記
5. 過時的依賴版本
6. 缺少測試的核心模組
7. 硬編碼的設定值

請以表格列出，包含：
- 位置（檔案:行數）
- 類型
- 嚴重度
- 建議修復方式

## 安全開發十誡

1. **輸入永遠不可信** — 驗證所有外部輸入
2. **使用參數化查詢** — 永不拼接 SQL
3. **加密儲存敏感資料** — 密碼用 BCrypt，資料用 AES-256
4. **傳輸全程加密** — TLS 1.3
5. **最小權限原則** — 角色只授予必要權限
6. **稽核所有敏感操作** — 記錄 Who / What / When / Where
7. **日誌不記密資** — 禁止記錄密碼、Token、完整帳號
8. **依賴持續掃描** — Dependabot + OWASP DC 定期執行
9. **錯誤不洩系統資訊** — 統一錯誤回應格式
10. **定期安全訓練** — 每季至少一次 OWASP 培訓

# 排除機密檔案不被 Copilot 存取
- "**/*.env"
- "**/*secret*"
- "**/config/credentials/**"
- "internal-docs/**"
- "compliance/**"

## AI 治理合規檢核

### 政策面
- [ ] 已制定 AI 使用政策並公告全組織
- [ ] 已定義 AI 工具核准清單
- [ ] 已建立 AI 生成程式碼的審查流程
- [ ] 已制定資料分級政策（何種資料不可輸入 AI）

### 技術面
- [ ] 已啟用 Organization Custom Instructions
- [ ] 已設定 Content Exclusion 排除機密檔案
- [ ] 已啟用公開程式碼過濾（Block matching public code）
- [ ] 已啟用稽核日誌並設定保留期限
- [ ] 已設定 Agent Firewall 限制 Cloud Agent 存取範圍

### 管理面
- [ ] 定期審查 Copilot 座位指派（≤ 每月 1 次）
- [ ] 定期檢視稽核日誌異常行為（≤ 每週 1 次）
- [ ] 每季執行 AI 安全風險評估
- [ ] 每年進行 AI 使用政策更新

### 教育訓練
- [ ] 新進人員包含 AI 工具使用訓練
- [ ] 每季舉辦 Prompt Engineering 工作坊
- [ ] 每年至少 1 次 AI 安全與合規培訓
- [ ] 建立 AI 最佳實務知識庫並持續更新

## 環境建置
- [ ] VS Code 已安裝
- [ ] GitHub Copilot + Chat 已啟用
- [ ] Git / GitHub CLI 已設定
- [ ] Java 21 + Maven 已安裝
- [ ] Node.js（前端需要）已安裝

## Copilot 設定
- [ ] copilot-instructions.md 已建立
- [ ] Custom Instructions 已設定
- [ ] Copilot Memory 已啟用
- [ ] Copilot Spaces 已建立（如需要）
- [ ] MCP Server 已設定（如需要）

## 專案設定
- [ ] Git Repo 已建立
- [ ] Branch Protection Rules 已設定
- [ ] CI/CD Pipeline 已設定
- [ ] Code Review 規則已設定
- [ ] Security Scanning 已啟用（CodeQL / Dependabot）

## 文件
- [ ] README.md 已撰寫
- [ ] API Spec（OpenAPI）已定義
- [ ] 架構設計文件已完成
- [ ] 安全規範已制定

## 開發前
- [ ] 確認需求與設計
- [ ] 從最新 develop 分支建立 feature branch
- [ ] 確認 Copilot 正常運作

## 開發中
- [ ] 使用 Copilot 輔助但人工審查每段程式碼
- [ ] 不將敏感資訊作為 Prompt
- [ ] 遵循 Clean Architecture 分層
- [ ] 即時撰寫測試

## 提交前
- [ ] 本地測試全數通過
- [ ] 程式碼格式化（mvn spotless:apply）
- [ ] Commit Message 符合 Conventional Commits
- [ ] 無敏感資訊在程式碼中

## PR 建立
- [ ] PR 描述清楚完整
- [ ] 已 Self-Review
- [ ] 已指派 Reviewer
- [ ] CI Pipeline 全數通過
- [ ] Copilot Code Review 建議已處理

## 認證授權
- [ ] JWT Token 驗證完整
- [ ] RBAC 權限檢查正確
- [ ] Session 管理安全（HttpOnly, Secure, SameSite）
- [ ] 密碼加密儲存（BCrypt）

## 輸入驗證
- [ ] 所有外部輸入已驗證
- [ ] SQL 使用 Prepared Statement
- [ ] XSS 防護（輸出編碼）
- [ ] CSRF Token 設定

## 資料保護
- [ ] 傳輸加密（TLS 1.3）
- [ ] 敏感資料加密儲存
- [ ] 個資適當遮罩
- [ ] 日誌不含敏感資訊

## 依賴安全
- [ ] 無已知 Critical/High 弱點
- [ ] Dependabot 已啟用
- [ ] Container Image 已掃描

## 部署前
- [ ] 所有測試通過
- [ ] Code Review 完成
- [ ] Security Scan 通過
- [ ] 版本號已更新
- [ ] CHANGELOG 已更新
- [ ] 資料庫 Migration 已準備
- [ ] 回滾計畫已文件化

## 部署中
- [ ] 資料備份完成
- [ ] 部署腳本執行成功
- [ ] 健康檢查通過

## 部署後
- [ ] 冒煙測試通過
- [ ] 監控指標正常
- [ ] 無異常告警
- [ ] 部署結果已通知

@workspace 請根據以下業務需求，產出完整的 User Story（含驗收條件、非功能性需求）：
[業務需求描述]

@workspace 請根據以下需求設計系統架構（含元件圖、資料流、安全設計）：
技術棧：[技術棧]
需求：[需求描述]

@workspace 請根據 Clean Architecture 產生 [功能名稱] 的完整後端程式碼：
- Controller + DTO
- Application Service
- Domain Model + Repository 介面
- Infrastructure Repository 實作
遵循專案 copilot-instructions.md 規範

@workspace 請用 Vue 3 + TypeScript + Tailwind CSS 產生 [頁面名稱]：
- 使用 Composition API
- 呼叫 [API 端點]
- 包含 Loading / Error 狀態
- 響應式設計

@workspace 請為 #file:[檔案路徑] 產生完整的 JUnit 5 測試：
- 使用 Mockito
- @DisplayName 中文說明
- Given-When-Then 模式
- 覆蓋所有分支（正常、異常、邊界）

@workspace 請對 #file:[檔案路徑] 進行 OWASP Top 10 安全審查，
列出發現的問題（含風險等級）和修復程式碼。

@workspace 請產生 GitHub Actions CI/CD Pipeline YAML：
- Build + Test
- SonarQube 掃描
- Security Scan（OWASP DC + CodeQL）
- Docker Build + Push
- Kubernetes 部署（Blue-Green）
- 環境分層：DEV / SIT / UAT / PROD

@workspace 系統出現以下錯誤，請協助診斷：
[錯誤日誌]
請提供：根因分析、影響評估、修復方案、預防措施。