# Windows - 使用 winget 安裝 JDK 21
winget install EclipseAdoptium.Temurin.21.JDK

# 驗證安裝
java -version
# 預期輸出: openjdk version "21.x.x"

# 設定 JAVA_HOME（系統環境變數）
[System.Environment]::SetEnvironmentVariable("JAVA_HOME", "C:\Program Files\Eclipse Adoptium\jdk-21.0.x-hotspot", "Machine")

# Windows - 使用 winget
winget install Apache.Maven

# 或手動下載後設定環境變數
# 1. 從 https://maven.apache.org/download.cgi 下載
# 2. 解壓至 C:\tools\apache-maven-3.9.9
# 3. 設定環境變數

[System.Environment]::SetEnvironmentVariable("MAVEN_HOME", "C:\tools\apache-maven-3.9.9", "Machine")
$path = [System.Environment]::GetEnvironmentVariable("Path", "Machine")
[System.Environment]::SetEnvironmentVariable("Path", "$path;C:\tools\apache-maven-3.9.9\bin", "Machine")

# 驗證
mvn -version

# 在終端執行批次安裝
code --install-extension vscjava.vscode-java-pack
code --install-extension vmware.vscode-boot-dev-pack
code --install-extension github.copilot
code --install-extension github.copilot-chat
code --install-extension humao.rest-client
code --install-extension eamodio.gitlens
code --install-extension sonarsource.sonarlint-vscode
code --install-extension redhat.vscode-xml
code --install-extension redhat.vscode-yaml
code --install-extension usernamehw.errorlens

{
    // Java 設定
    "java.configuration.runtimes": [
        {
            "name": "JavaSE-21",
            "path": "C:\\Program Files\\Eclipse Adoptium\\jdk-21.0.5-hotspot",
            "default": true
        }
    ],
    "java.jdt.ls.java.home": "C:\\Program Files\\Eclipse Adoptium\\jdk-21.0.5-hotspot",
    "java.compile.nullAnalysis.mode": "automatic",
    
    // Maven 設定
    "java.configuration.maven.userSettings": "C:\\Users\\<USER>\\.m2\\settings.xml",
    "maven.executable.path": "C:\\tools\\apache-maven-3.9.9\\bin\\mvn.cmd",
    "maven.terminal.useJavaHome": true,
    
    // 編輯器設定
    "editor.fontSize": 14,
    "editor.tabSize": 4,
    "editor.formatOnSave": true,
    "editor.minimap.enabled": false,
    "files.encoding": "utf8",
    "files.autoSave": "afterDelay",
    
    // Copilot 設定
    "github.copilot.enable": {
        "*": true,
        "yaml": true,
        "markdown": true,
        "json": true
    },
    "github.copilot.chat.localeOverride": "zh-TW",
    
    // 終端設定
    "terminal.integrated.defaultProfile.windows": "PowerShell",
    "terminal.integrated.fontSize": 13
}

{
    "java.configuration.updateBuildConfiguration": "automatic",
    "java.format.settings.url": ".vscode/java-formatter.xml",
    "java.saveActions.organizeImports": true,
    "editor.codeActionsOnSave": {
        "source.organizeImports": "explicit"
    },
    "files.exclude": {
        "**/target": true,
        "**/.classpath": true,
        "**/.project": true,
        "**/.settings": true,
        "**/.factorypath": true
    }
}

# 驗證所有工具
java -version        # Java 21+
mvn -version         # Maven 3.9+
git --version        # Git 2.40+
code --version       # VS Code 1.126+

/init

.github/
├── copilot-instructions.md   ← 全域自訂指令
├── prompts/
│   ├── code-review.prompt.md   ← Code Review Prompt
│   └── test-gen.prompt.md      ← 測試生成 Prompt
├── agents/
│   └── spring-expert.agent.md  ← Spring Boot 專家 Agent
└── skills/
    └── db-migration.skill.md   ← DB Migration 技能

# 專案開發指引

- 使用 Java 21、Spring Boot 3.4.x
- 遵循 Clean Architecture 分層
- 所有 API 端點需有 @Valid 驗證
- Service 層需包含 @Transactional
- 例外處理使用 @RestControllerAdvice
- 繁體中文註解
- 单元測試使用 JUnit 5 + Mockito

---
name: spring-expert
description: "Spring Boot 專家 Agent，負責架構設計與 Code Review"
tools:
  - semantic_search
  - run_in_terminal
  - read_file
---

你是一位資深 Spring Boot 專家。請在回答時：
1. 始終引用 Spring 官方最佳實務
2. 程式碼遵循本專案 copilot-instructions.md
3. 提供 OWASP Top 10 安全建議

@workspace /new 建立一個 Spring Boot 3.4 Maven 專案，Group ID 為 com.bank.demo，
包含 Web、JPA、Security、Actuator、Lombok、H2、Validation 依賴

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.4.1</version>
        <relativePath/>
    </parent>
    
    <groupId>com.bank.demo</groupId>
    <artifactId>banking-api</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>banking-api</name>
    <description>Banking API Demo Project</description>
    
    <properties>
        <java.version>21</java.version>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        
        <!-- 測試依賴 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

banking-api/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/bank/demo/
│   │   │       ├── BankingApiApplication.java      ← 啟動類
│   │   │       ├── controller/                      ← REST API 端點
│   │   │       │   └── AccountController.java
│   │   │       ├── service/                         ← 業務邏輯層
│   │   │       │   ├── AccountService.java          ← 介面
│   │   │       │   └── impl/
│   │   │       │       └── AccountServiceImpl.java  ← 實作
│   │   │       ├── repository/                      ← 資料存取層
│   │   │       │   └── AccountRepository.java
│   │   │       ├── entity/                          ← JPA Entity
│   │   │       │   └── Account.java
│   │   │       ├── dto/                             ← 資料傳輸物件
│   │   │       │   ├── request/
│   │   │       │   │   └── CreateAccountRequest.java
│   │   │       │   └── response/
│   │   │       │       └── AccountResponse.java
│   │   │       ├── config/                          ← 設定類
│   │   │       │   └── SecurityConfig.java
│   │   │       └── exception/                       ← 全域例外處理
│   │   │           ├── GlobalExceptionHandler.java
│   │   │           └── BusinessException.java
│   │   └── resources/
│   │       ├── application.yml                      ← 主設定檔
│   │       ├── application-dev.yml                  ← 開發環境
│   │       └── application-prod.yml                 ← 正式環境
│   └── test/
│       └── java/
│           └── com/bank/demo/
│               ├── controller/
│               │   └── AccountControllerTest.java
│               └── service/
│                   └── AccountServiceTest.java
├── .vscode/
│   ├── settings.json
│   ├── launch.json
│   └── tasks.json
├── .github/
│   ├── copilot-instructions.md                      ← Copilot 專案指引
│   └── workflows/
│       └── ci.yml
├── pom.xml
└── README.md

server:
  port: 8080
  
spring:
  application:
    name: banking-api
  datasource:
    url: jdbc:h2:mem:bankingdb
    driver-class-name: org.h2.Driver
    username: sa
    password: 
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true
  h2:
    console:
      enabled: true
      path: /h2-console

# Actuator
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics

package com.bank.demo.controller;

import com.bank.demo.dto.response.AccountResponse;
import com.bank.demo.service.AccountService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 帳戶管理 REST API
 */
@RestController
@RequestMapping("/api/v1/accounts")
@RequiredArgsConstructor
public class AccountController {

    private final AccountService accountService;

    /**
     * 查詢所有帳戶
     * @return 帳戶清單
     */
    @GetMapping
    public ResponseEntity<List<AccountResponse>> getAllAccounts() {
        return ResponseEntity.ok(accountService.findAll());
    }

    /**
     * 依帳號查詢
     * @param accountNumber 帳號
     * @return 帳戶資訊
     */
    @GetMapping("/{accountNumber}")
    public ResponseEntity<AccountResponse> getAccount(
            @PathVariable String accountNumber) {
        return ResponseEntity.ok(accountService.findByAccountNumber(accountNumber));
    }
}

# 方法 1：VS Code 終端
mvn spring-boot:run

# 方法 2：VS Code Spring Boot Dashboard
# 點擊左側 Spring Boot 圖示 → 按下 ▶️ 啟動

### 健康檢查
GET http://localhost:8080/actuator/health
Content-Type: application/json

### 查詢所有帳戶
GET http://localhost:8080/api/v1/accounts
Content-Type: application/json

### 建立帳戶
POST http://localhost:8080/api/v1/accounts
Content-Type: application/json

{
    "accountNumber": "0001-2345-6789",
    "accountName": "王小明",
    "balance": 100000.00,
    "accountType": "SAVINGS"
}

Ctrl + Shift + P → Simple Browser: Show
輸入 URL：http://localhost:8080

// 只需輸入方法簽名和註解，Copilot 會自動產生完整實作
/**
 * 計算帳戶利息
 * @param balance 帳戶餘額
 * @param annualRate 年利率
 * @param days 天數
 * @return 利息金額
 */
public BigDecimal calculateInterest(BigDecimal balance, BigDecimal annualRate, int days) {
    // Copilot 自動補全 ↓
    return balance
        .multiply(annualRate)
        .multiply(BigDecimal.valueOf(days))
        .divide(BigDecimal.valueOf(365), 2, RoundingMode.HALF_UP);
}

# 選取一段程式碼後按 Ctrl+I

重構這段程式，使用 Stream API 替代 for 迴圈
加入 null check 並拋出 BusinessException
將這個方法拆分為兩個更小的方法

// 建立一個帳戶交易紀錄的 Entity，包含交易編號、帳號、交易類型（存款/提款/轉帳）、
// 金額、交易時間、備註，使用 JPA 註解映射到 transaction_records 表
// Copilot 將自動產生以下 Entity ↓

@Entity
@Table(name = "transaction_records")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class TransactionRecord {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "transaction_no", unique = true, nullable = false, length = 32)
    private String transactionNo;

    @Column(name = "account_number", nullable = false, length = 20)
    private String accountNumber;

    @Enumerated(EnumType.STRING)
    @Column(name = "transaction_type", nullable = false)
    private TransactionType transactionType;

    @Column(name = "amount", nullable = false, precision = 18, scale = 2)
    private BigDecimal amount;

    @Column(name = "transaction_time", nullable = false)
    private LocalDateTime transactionTime;

    @Column(name = "remark", length = 500)
    private String remark;

    public enum TransactionType {
        DEPOSIT,    // 存款
        WITHDRAWAL, // 提款
        TRANSFER    // 轉帳
    }
}

@workspace 根據 AccountController 和 Account Entity，
幫我生成完整的 AccountService 介面和 AccountServiceImpl 實作類別，
包含：
1. CRUD 操作
2. 轉帳功能（含交易紀錄）
3. 使用 @Transactional 管理交易
4. 適當的例外處理
5. 使用 Slf4j 記錄日誌

package com.bank.demo.service;

import com.bank.demo.dto.request.CreateAccountRequest;
import com.bank.demo.dto.request.TransferRequest;
import com.bank.demo.dto.response.AccountResponse;

import java.util.List;

/**
 * 帳戶服務介面
 */
public interface AccountService {
    
    AccountResponse create(CreateAccountRequest request);
    
    AccountResponse findByAccountNumber(String accountNumber);
    
    List<AccountResponse> findAll();
    
    AccountResponse update(String accountNumber, CreateAccountRequest request);
    
    void delete(String accountNumber);
    
    void transfer(TransferRequest request);
}

package com.bank.demo.service.impl;

import com.bank.demo.dto.request.CreateAccountRequest;
import com.bank.demo.dto.request.TransferRequest;
import com.bank.demo.dto.response.AccountResponse;
import com.bank.demo.entity.Account;
import com.bank.demo.exception.BusinessException;
import com.bank.demo.repository.AccountRepository;
import com.bank.demo.service.AccountService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 帳戶服務實作
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class AccountServiceImpl implements AccountService {

    private final AccountRepository accountRepository;

    @Override
    @Transactional
    public AccountResponse create(CreateAccountRequest request) {
        log.info("建立帳戶: {}", request.getAccountNumber());
        
        if (accountRepository.existsByAccountNumber(request.getAccountNumber())) {
            throw new BusinessException("帳號已存在: " + request.getAccountNumber());
        }
        
        Account account = Account.builder()
                .accountNumber(request.getAccountNumber())
                .accountName(request.getAccountName())
                .balance(request.getBalance())
                .accountType(request.getAccountType())
                .build();
        
        Account saved = accountRepository.save(account);
        log.info("帳戶建立成功: {}", saved.getAccountNumber());
        return toResponse(saved);
    }

    @Override
    @Transactional(readOnly = true)
    public AccountResponse findByAccountNumber(String accountNumber) {
        return accountRepository.findByAccountNumber(accountNumber)
                .map(this::toResponse)
                .orElseThrow(() -> new BusinessException("帳戶不存在: " + accountNumber));
    }

    @Override
    @Transactional(readOnly = true)
    public List<AccountResponse> findAll() {
        return accountRepository.findAll().stream()
                .map(this::toResponse)
                .collect(Collectors.toList());
    }

    @Override
    @Transactional
    public void transfer(TransferRequest request) {
        log.info("轉帳: {} -> {}, 金額: {}", 
                request.getFromAccount(), request.getToAccount(), request.getAmount());
        
        Account from = accountRepository.findByAccountNumber(request.getFromAccount())
                .orElseThrow(() -> new BusinessException("轉出帳戶不存在"));
        
        Account to = accountRepository.findByAccountNumber(request.getToAccount())
                .orElseThrow(() -> new BusinessException("轉入帳戶不存在"));
        
        if (from.getBalance().compareTo(request.getAmount()) < 0) {
            throw new BusinessException("餘額不足，目前餘額: " + from.getBalance());
        }
        
        from.setBalance(from.getBalance().subtract(request.getAmount()));
        to.setBalance(to.getBalance().add(request.getAmount()));
        
        accountRepository.save(from);
        accountRepository.save(to);
        
        log.info("轉帳成功: {} -> {}, 金額: {}", 
                request.getFromAccount(), request.getToAccount(), request.getAmount());
    }

    @Override
    @Transactional
    public AccountResponse update(String accountNumber, CreateAccountRequest request) {
        Account account = accountRepository.findByAccountNumber(accountNumber)
                .orElseThrow(() -> new BusinessException("帳戶不存在: " + accountNumber));
        
        account.setAccountName(request.getAccountName());
        account.setAccountType(request.getAccountType());
        
        return toResponse(accountRepository.save(account));
    }

    @Override
    @Transactional
    public void delete(String accountNumber) {
        Account account = accountRepository.findByAccountNumber(accountNumber)
                .orElseThrow(() -> new BusinessException("帳戶不存在: " + accountNumber));
        accountRepository.delete(account);
        log.info("帳戶已刪除: {}", accountNumber);
    }

    private AccountResponse toResponse(Account account) {
        return AccountResponse.builder()
                .accountNumber(account.getAccountNumber())
                .accountName(account.getAccountName())
                .balance(account.getBalance())
                .accountType(account.getAccountType())
                .build();
    }
}

/tests 請為 AccountServiceImpl 生成完整的 JUnit 5 測試，
使用 Mockito mock AccountRepository，
需涵蓋：正常路徑、帳戶不存在、餘額不足等測試案例

package com.bank.demo.service;

import com.bank.demo.dto.request.CreateAccountRequest;
import com.bank.demo.dto.request.TransferRequest;
import com.bank.demo.dto.response.AccountResponse;
import com.bank.demo.entity.Account;
import com.bank.demo.exception.BusinessException;
import com.bank.demo.repository.AccountRepository;
import com.bank.demo.service.impl.AccountServiceImpl;
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 java.math.BigDecimal;
import java.util.Optional;

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

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

    @Mock
    private AccountRepository accountRepository;

    @InjectMocks
    private AccountServiceImpl accountService;

    private Account testAccount;

    @BeforeEach
    void setUp() {
        testAccount = Account.builder()
                .id(1L)
                .accountNumber("0001-2345-6789")
                .accountName("王小明")
                .balance(new BigDecimal("100000.00"))
                .accountType("SAVINGS")
                .build();
    }

    @Nested
    @DisplayName("查詢帳戶")
    class FindAccountTests {

        @Test
        @DisplayName("帳號存在時應回傳帳戶資訊")
        void shouldReturnAccountWhenExists() {
            when(accountRepository.findByAccountNumber("0001-2345-6789"))
                    .thenReturn(Optional.of(testAccount));

            AccountResponse response = accountService
                    .findByAccountNumber("0001-2345-6789");

            assertThat(response.getAccountNumber()).isEqualTo("0001-2345-6789");
            assertThat(response.getAccountName()).isEqualTo("王小明");
        }

        @Test
        @DisplayName("帳號不存在時應拋出 BusinessException")
        void shouldThrowWhenAccountNotFound() {
            when(accountRepository.findByAccountNumber("9999-9999-9999"))
                    .thenReturn(Optional.empty());

            assertThatThrownBy(() -> 
                    accountService.findByAccountNumber("9999-9999-9999"))
                    .isInstanceOf(BusinessException.class)
                    .hasMessageContaining("帳戶不存在");
        }
    }

    @Nested
    @DisplayName("轉帳功能")
    class TransferTests {

        @Test
        @DisplayName("餘額充足時轉帳應成功")
        void shouldTransferSuccessfully() {
            Account toAccount = Account.builder()
                    .id(2L)
                    .accountNumber("0002-3456-7890")
                    .accountName("李大華")
                    .balance(new BigDecimal("50000.00"))
                    .build();

            when(accountRepository.findByAccountNumber("0001-2345-6789"))
                    .thenReturn(Optional.of(testAccount));
            when(accountRepository.findByAccountNumber("0002-3456-7890"))
                    .thenReturn(Optional.of(toAccount));

            TransferRequest request = TransferRequest.builder()
                    .fromAccount("0001-2345-6789")
                    .toAccount("0002-3456-7890")
                    .amount(new BigDecimal("30000.00"))
                    .build();

            accountService.transfer(request);

            assertThat(testAccount.getBalance())
                    .isEqualByComparingTo("70000.00");
            assertThat(toAccount.getBalance())
                    .isEqualByComparingTo("80000.00");
            verify(accountRepository, times(2)).save(any(Account.class));
        }

        @Test
        @DisplayName("餘額不足時應拋出例外")
        void shouldThrowWhenInsufficientBalance() {
            Account toAccount = Account.builder()
                    .accountNumber("0002-3456-7890")
                    .balance(BigDecimal.ZERO)
                    .build();

            when(accountRepository.findByAccountNumber("0001-2345-6789"))
                    .thenReturn(Optional.of(testAccount));
            when(accountRepository.findByAccountNumber("0002-3456-7890"))
                    .thenReturn(Optional.of(toAccount));

            TransferRequest request = TransferRequest.builder()
                    .fromAccount("0001-2345-6789")
                    .toAccount("0002-3456-7890")
                    .amount(new BigDecimal("200000.00"))
                    .build();

            assertThatThrownBy(() -> accountService.transfer(request))
                    .isInstanceOf(BusinessException.class)
                    .hasMessageContaining("餘額不足");
        }
    }
}

方法 1：Chat 面板 → 輸入框底部切換 Permission Level 為 Autopilot
方法 2：設定 chat.permissions.default 為 autopilot
方法 3：設定 chat.autopilot.advanced.enabled = true 啟用進階判定

方法 1：Chat 面板 → 切換至 Agent Mode（下拉選單）
方法 2：Ctrl + Shift + I → 選擇 Agent Mode
方法 3：使用 Plan Agent 先規劃再執行

在 Agent Mode 中輸入：

建立完整的「交易紀錄模組」（TransactionRecord），包含：
1. Entity（映射 transaction_records 表）
2. Repository（含自訂查詢：按帳號查、按日期範圍查）
3. Service + ServiceImpl（含交易紀錄新增、查詢）
4. Controller（REST API，路徑 /api/v1/transactions）
5. DTO（Request + Response）
6. JUnit 測試

放在 com.bank.demo.transaction 套件下，
遵循 #file:.github/copilot-instructions.md 的規範

將 AccountServiceImpl 中的轉帳邏輯抽取為獨立的 TransferService，
並確保：
1. 原有測試仍然通過
2. 新增 TransferService 的單元測試
3. Controller 改為注入 TransferService
4. 使用 @Transactional 管理事務

在 Chat 中使用 Plan Agent：

@plan 我想將目前的單體架構拆分為以下微服務：
1. user-service（使用者管理）
2. account-service（帳戶管理）
3. transaction-service（交易管理）
請列出詳細的實作步驟、需要修改的檔案清單、以及可能的風險

主 Agent → 呼叫 Spring Expert Subagent（分析架構）
         → 呼叫 Test Subagent（生成測試）
         → 呼叫 Security Subagent（安全審查）

Ctrl + Shift + P → Agents: Open Agents Window
或從 Activity Bar 的 Agents 圖示開啟

# 在 Chat 中使用 Chronicle 指令

/chronicle search 上週我做了哪些 Spring Boot 相關的修改？
/chronicle standup 產生今日站會報告
/chronicle tips 根據我的開發習慣給出建議

情境：主 Chat 正在讓 Agent 實作功能
→ 點擊 Session 工具列的 "+" 開啟第二個 Chat
→ 第二個 Chat 用來 Review 程式碼或撰寫測試
→ 兩個 Chat 共享相同 Session 和工作上下文
→ 各 Chat 保有獨立對話歷史

/research Spring Boot 3.4 的 Virtual Threads 最佳實務，
包含效能基準、已知限制、以及在 Web MVC 和 WebFlux 中的差異

# Copilot 專案指引

## 程式碼風格
- 使用 Java 21 語法特徵（Record、Pattern Matching、Sealed Class）
- 方法必須有 JavaDoc 註解
- 使用 Lombok 減少 Boilerplate
- 日誌使用 Slf4j（@Slf4j）

## 架構規範
- Controller 只負責接收請求和回傳回應
- 業務邏輯放在 Service 層
- 使用 DTO 傳輸資料，禁止直接回傳 Entity
- 使用 @Transactional 管理事務

## 測試規範
- 使用 JUnit 5 + Mockito
- 測試方法命名：should_預期結果_when_條件
- 每個 Service 方法至少 2 個測試案例

## 安全規範
- 禁止在日誌中記錄密碼或個資
- SQL 查詢使用參數化，禁止字串拼接
- API 必須有輸入驗證（@Valid）

參考 #file:AccountController.java 的風格，
建立 TransactionController，路徑 /api/v1/transactions

步驟 1：先建立 Transaction Entity
步驟 2：建立 TransactionRepository（含自訂查詢）
步驟 3：建立 TransactionService（含轉帳邏輯）
步驟 4：建立 TransactionController
步驟 5：建立對應的測試

@workspace 使用 Agent Mode，幫我建立完整的「客戶管理模組」（Customer），
包含 Entity、Repository、Service、Controller、DTO、測試，
放在 com.bank.demo.customer 套件下

{
    "mcp": {
        "servers": {
            "github": {
                "command": "npx",
                "args": ["-y", "@modelcontextprotocol/server-github"],
                "env": {
                    "GITHUB_PERSONAL_ACCESS_TOKEN": "${env:GITHUB_TOKEN}"
                }
            },
            "database": {
                "command": "npx",
                "args": ["-y", "@modelcontextprotocol/server-postgres"],
                "env": {
                    "DATABASE_URL": "postgresql://localhost:5432/bankingdb"
                }
            }
        }
    }
}

# 在 Agent Mode 中，Agent 可自動呼叫 MCP Server

查詢 bankingdb 的 accounts 表結構，
然後根據結構建立對應的 JPA Entity 和 Repository

{
    "my-mcp-server": {
        "url": "https://mcp.example.com/mcp",
        "type": "http",
        "oauth": {
            "clientId": "your-client-id"
        }
    }
}

---
# .github/prompts/code-review.prompt.md
description: "Spring Boot Code Review Prompt"
---
請根據以下檢查清單進行 Code Review：

1. **安全性**：是否有 SQL Injection、XSS、CSRF 風險？
2. **效能**：是否有 N+1 查詢、不必要的資料庫呼叫？
3. **交易管理**：@Transactional 範圍是否正確？
4. **例外處理**：是否有適當的錯誤處理和回傳格式？
5. **日誌**：是否記錄足夠的操作日誌？
6. **測試覆蓋**：是否有對應的單元測試？

---
# .github/skills/db-migration.skill.md
name: db-migration
description: "產生 Flyway DB Migration 腳本"
tools:
  - read_file
  - create_file
  - run_in_terminal
---
當需要修改資料庫結構時：
1. 讀取現有的 Entity 定義
2. 比對目標結構
3. 產生 Flyway V{timestamp}__description.sql
4. 將 SQL 放在 src/main/resources/db/migration/
5. 執行 mvn flyway:migrate 驗證

---
# .github/agents/security-auditor.agent.md
name: security-auditor
description: "專業安全審計 Agent"
tools:
  - semantic_search
  - read_file
  - grep_search
---
你是一位專業的 Java Web 應用安全審計專家。

## 審計範圍
1. OWASP Top 10 檢查
2. Spring Security 設定審查
3. 敏感資料保護（PII、密碼、金鑰）
4. JWT Token 安全性
5. API Rate Limiting

## 輸出格式
產生結構化的安全報告，包含：
- 風險等級（Critical/High/Medium/Low）
- 問題描述
- 影響範圍
- 修復建議
- 程式碼範例

com.bank.demo/
├── domain/                          ← 核心領域（不依賴任何框架）
│   ├── model/
│   │   ├── Account.java             ← Domain Entity（非 JPA Entity）
│   │   ├── Transaction.java
│   │   └── Money.java               ← Value Object
│   ├── repository/
│   │   └── AccountRepository.java   ← Port（純 Interface）
│   ├── service/
│   │   └── TransferDomainService.java  ← Domain Service
│   └── exception/
│       └── DomainException.java
│
├── application/                     ← 應用層（Use Cases）
│   ├── usecase/
│   │   ├── CreateAccountUseCase.java
│   │   ├── TransferMoneyUseCase.java
│   │   └── QueryAccountUseCase.java
│   ├── dto/
│   │   ├── command/
│   │   │   ├── CreateAccountCommand.java
│   │   │   └── TransferCommand.java
│   │   └── query/
│   │       └── AccountQuery.java
│   └── port/
│       └── output/
│           └── NotificationPort.java  ← 對外通知介面
│
├── infrastructure/                  ← 基礎設施層
│   ├── persistence/
│   │   ├── entity/
│   │   │   └── AccountJpaEntity.java  ← JPA Entity（資料庫映射）
│   │   ├── repository/
│   │   │   └── AccountJpaRepository.java
│   │   └── adapter/
│   │       └── AccountRepositoryAdapter.java  ← Port 實作
│   ├── config/
│   │   ├── SecurityConfig.java
│   │   └── JpaConfig.java
│   └── external/
│       └── NotificationAdapter.java   ← 通知實作（Email/SMS）
│
└── presentation/                    ← 展示層
    ├── controller/
    │   └── AccountController.java
    ├── dto/
    │   ├── request/
    │   │   └── CreateAccountRequest.java
    │   └── response/
    │       └── AccountResponse.java
    └── advice/
        └── GlobalExceptionHandler.java

package com.bank.demo.application.usecase;

import com.bank.demo.application.dto.command.TransferCommand;
import com.bank.demo.domain.exception.DomainException;
import com.bank.demo.domain.model.Account;
import com.bank.demo.domain.model.Money;
import com.bank.demo.domain.repository.AccountRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * 轉帳 Use Case
 * <p>
 * 職責：協調領域物件完成轉帳流程
 * </p>
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class TransferMoneyUseCase {

    private final AccountRepository accountRepository;

    @Transactional
    public void execute(TransferCommand command) {
        log.info("執行轉帳: {} -> {}, 金額: {}", 
                command.fromAccountNumber(), 
                command.toAccountNumber(), 
                command.amount());

        Account from = accountRepository
                .findByAccountNumber(command.fromAccountNumber())
                .orElseThrow(() -> new DomainException("轉出帳戶不存在"));

        Account to = accountRepository
                .findByAccountNumber(command.toAccountNumber())
                .orElseThrow(() -> new DomainException("轉入帳戶不存在"));

        Money transferAmount = Money.of(command.amount());
        
        // 領域邏輯在 Domain Entity 中
        from.withdraw(transferAmount);
        to.deposit(transferAmount);

        accountRepository.save(from);
        accountRepository.save(to);

        log.info("轉帳完成");
    }
}

package com.bank.demo.domain.model;

import com.bank.demo.domain.exception.DomainException;

/**
 * 帳戶領域物件
 */
public class Account {
    
    private Long id;
    private String accountNumber;
    private String accountName;
    private Money balance;
    private AccountStatus status;

    /**
     * 存款
     */
    public void deposit(Money amount) {
        if (amount.isNegativeOrZero()) {
            throw new DomainException("存款金額必須大於零");
        }
        this.balance = this.balance.add(amount);
    }

    /**
     * 提款
     */
    public void withdraw(Money amount) {
        if (amount.isNegativeOrZero()) {
            throw new DomainException("提款金額必須大於零");
        }
        if (this.status != AccountStatus.ACTIVE) {
            throw new DomainException("帳戶非啟用狀態，無法提款");
        }
        if (this.balance.isLessThan(amount)) {
            throw new DomainException("餘額不足，目前餘額: " + this.balance);
        }
        this.balance = this.balance.subtract(amount);
    }

    /**
     * 凍結帳戶
     */
    public void freeze() {
        this.status = AccountStatus.FROZEN;
    }

    public enum AccountStatus {
        ACTIVE, FROZEN, CLOSED
    }
}

package com.bank.demo.domain.model;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Objects;

/**
 * 金額值物件（不可變）
 * 
 * @param amount 金額
 * @param currency 幣別
 */
public record Money(BigDecimal amount, String currency) {

    public static final String DEFAULT_CURRENCY = "TWD";

    public Money {
        Objects.requireNonNull(amount, "金額不可為 null");
        Objects.requireNonNull(currency, "幣別不可為 null");
        amount = amount.setScale(2, RoundingMode.HALF_UP);
    }

    public static Money of(BigDecimal amount) {
        return new Money(amount, DEFAULT_CURRENCY);
    }

    public static Money zero() {
        return new Money(BigDecimal.ZERO, DEFAULT_CURRENCY);
    }

    public Money add(Money other) {
        validateCurrency(other);
        return new Money(this.amount.add(other.amount), this.currency);
    }

    public Money subtract(Money other) {
        validateCurrency(other);
        return new Money(this.amount.subtract(other.amount), this.currency);
    }

    public boolean isNegativeOrZero() {
        return amount.compareTo(BigDecimal.ZERO) <= 0;
    }

    public boolean isLessThan(Money other) {
        validateCurrency(other);
        return amount.compareTo(other.amount) < 0;
    }

    private void validateCurrency(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException(
                "幣別不一致: " + this.currency + " vs " + other.currency);
        }
    }
}

// Request DTO
package com.bank.demo.presentation.dto.request;

import jakarta.validation.constraints.*;
import java.math.BigDecimal;

/**
 * 建立帳戶請求
 */
public record CreateAccountRequest(
    
    @NotBlank(message = "帳號不可為空")
    @Pattern(regexp = "^\\d{4}-\\d{4}-\\d{4}$", message = "帳號格式錯誤")
    String accountNumber,
    
    @NotBlank(message = "戶名不可為空")
    @Size(max = 50, message = "戶名長度不可超過 50")
    String accountName,
    
    @NotNull(message = "金額不可為空")
    @DecimalMin(value = "0", message = "金額不可為負數")
    BigDecimal balance,
    
    @NotBlank(message = "帳戶類型不可為空")
    String accountType
) {}

// Response DTO
package com.bank.demo.presentation.dto.response;

import lombok.Builder;
import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * 帳戶回應
 */
@Builder
public record AccountResponse(
    String accountNumber,
    String accountName,
    BigDecimal balance,
    String accountType,
    LocalDateTime createdAt
) {}

package com.bank.demo.infrastructure.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

/**
 * Spring Security 設定
 */
@Configuration
@EnableWebSecurity
public class SecurityConfig {

    private final JwtAuthenticationFilter jwtAuthFilter;

    public SecurityConfig(JwtAuthenticationFilter jwtAuthFilter) {
        this.jwtAuthFilter = jwtAuthFilter;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
                .csrf(csrf -> csrf.disable())         // REST API 不需 CSRF
                .sessionManagement(session -> 
                    session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                .authorizeHttpRequests(auth -> auth
                    // 開放端點
                    .requestMatchers("/api/v1/auth/**").permitAll()
                    .requestMatchers("/actuator/health").permitAll()
                    .requestMatchers("/h2-console/**").permitAll()
                    .requestMatchers("/swagger-ui/**", "/v3/api-docs/**").permitAll()
                    // 需認證
                    .requestMatchers("/api/v1/admin/**").hasRole("ADMIN")
                    .anyRequest().authenticated()
                )
                .addFilterBefore(jwtAuthFilter, 
                    UsernamePasswordAuthenticationFilter.class)
                .build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12); // 強度 12
    }
}

package com.bank.demo.infrastructure.security;

import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.util.Date;

/**
 * JWT 工具類
 */
@Component
public class JwtTokenProvider {

    private final SecretKey secretKey;
    private final long expirationMs;

    public JwtTokenProvider(
            @Value("${app.jwt.secret}") String secret,
            @Value("${app.jwt.expiration-ms:3600000}") long expirationMs) {
        this.secretKey = Keys.hmacShaKeyFor(secret.getBytes(StandardCharsets.UTF_8));
        this.expirationMs = expirationMs;
    }

    /**
     * 產生 JWT Token
     */
    public String generateToken(String username, String role) {
        Date now = new Date();
        Date expiry = new Date(now.getTime() + expirationMs);

        return Jwts.builder()
                .subject(username)
                .claim("role", role)
                .issuedAt(now)
                .expiration(expiry)
                .signWith(secretKey)
                .compact();
    }

    /**
     * 解析 Token 取得使用者名稱
     */
    public String getUsernameFromToken(String token) {
        return parseClaims(token).getSubject();
    }

    /**
     * 驗證 Token 是否有效
     */
    public boolean validateToken(String token) {
        try {
            parseClaims(token);
            return true;
        } catch (JwtException | IllegalArgumentException e) {
            return false;
        }
    }

    private Claims parseClaims(String token) {
        return Jwts.parser()
                .verifyWith(secretKey)
                .build()
                .parseSignedClaims(token)
                .getPayload();
    }
}

package com.bank.demo.infrastructure.security;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

/**
 * JWT 認證過濾器
 */
@Component
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final JwtTokenProvider tokenProvider;
    private final UserDetailsService userDetailsService;

    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {

        String token = extractToken(request);

        if (StringUtils.hasText(token) && tokenProvider.validateToken(token)) {
            String username = tokenProvider.getUsernameFromToken(token);
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);

            UsernamePasswordAuthenticationToken authentication =
                    new UsernamePasswordAuthenticationToken(
                            userDetails, null, userDetails.getAuthorities());
            authentication.setDetails(
                    new WebAuthenticationDetailsSource().buildDetails(request));

            SecurityContextHolder.getContext().setAuthentication(authentication);
        }

        filterChain.doFilter(request, response);
    }

    private String extractToken(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

// ❌ Copilot 可能產生的不安全程式碼
@Query("SELECT a FROM Account a WHERE a.name = '" + name + "'")  // SQL Injection!
List<Account> findByName(String name);

// ✅ 正確寫法
@Query("SELECT a FROM Account a WHERE a.name = :name")
List<Account> findByName(@Param("name") String name);


// ❌ 密碼寫在程式碼中
String dbPassword = "P@ssw0rd123";

// ✅ 使用環境變數
@Value("${spring.datasource.password}")
String dbPassword;


// ❌ 日誌記錄敏感資料
log.info("使用者登入: password={}", password);

// ✅ 隱藏敏感資料
log.info("使用者登入: userId={}", userId);

src/test/java/
└── com/bank/demo/
    ├── domain/
    │   ├── model/
    │   │   ├── AccountTest.java          ← Domain Entity 測試
    │   │   └── MoneyTest.java            ← Value Object 測試
    │   └── service/
    │       └── TransferDomainServiceTest.java
    ├── application/
    │   └── usecase/
    │       └── TransferMoneyUseCaseTest.java  ← Use Case 測試（Mock）
    ├── presentation/
    │   └── controller/
    │       └── AccountControllerTest.java     ← API 測試（MockMvc）
    └── integration/
        └── AccountIntegrationTest.java        ← 整合測試

package com.bank.demo.presentation.controller;

import com.bank.demo.application.usecase.QueryAccountUseCase;
import com.bank.demo.presentation.dto.response.AccountResponse;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.web.servlet.MockMvc;

import java.math.BigDecimal;

import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@WebMvcTest(AccountController.class)
@DisplayName("帳戶 API 測試")
class AccountControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private QueryAccountUseCase queryAccountUseCase;

    @Test
    @WithMockUser(username = "testuser", roles = {"USER"})
    @DisplayName("GET /api/v1/accounts/{id} - 查詢帳戶成功")
    void shouldReturnAccountWhenExists() throws Exception {
        // Given
        AccountResponse response = AccountResponse.builder()
                .accountNumber("0001-2345-6789")
                .accountName("王小明")
                .balance(new BigDecimal("100000.00"))
                .accountType("SAVINGS")
                .build();

        when(queryAccountUseCase.findByAccountNumber("0001-2345-6789"))
                .thenReturn(response);

        // When & Then
        mockMvc.perform(get("/api/v1/accounts/0001-2345-6789")
                        .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.accountNumber").value("0001-2345-6789"))
                .andExpect(jsonPath("$.accountName").value("王小明"))
                .andExpect(jsonPath("$.balance").value(100000.00));
    }

    @Test
    @DisplayName("GET /api/v1/accounts/{id} - 未認證應回傳 401")
    void shouldReturn401WhenNotAuthenticated() throws Exception {
        mockMvc.perform(get("/api/v1/accounts/0001-2345-6789"))
                .andExpect(status().isUnauthorized());
    }
}

# 在 Copilot Chat 中：
@workspace /tests 為 #file:TransferMoneyUseCase.java 產生完整的測試，
使用 JUnit 5 + Mockito，涵蓋以下場景：
- 正常轉帳（驗證餘額變化）
- 轉出帳戶不存在
- 轉入帳戶不存在
- 餘額不足
- 金額為零或負數
- 同帳戶轉帳

@baseUrl = http://localhost:8080/api/v1
@token = {{login.response.body.token}}

### 登入取得 Token
# @name login
POST {{baseUrl}}/auth/login
Content-Type: application/json

{
    "username": "admin",
    "password": "admin123"
}

### 查詢所有帳戶
GET {{baseUrl}}/accounts
Authorization: Bearer {{token}}

### 建立帳戶
POST {{baseUrl}}/accounts
Authorization: Bearer {{token}}
Content-Type: application/json

{
    "accountNumber": "0001-2345-6789",
    "accountName": "王小明",
    "balance": 100000.00,
    "accountType": "SAVINGS"
}

### 轉帳
POST {{baseUrl}}/accounts/transfer
Authorization: Bearer {{token}}
Content-Type: application/json

{
    "fromAccount": "0001-2345-6789",
    "toAccount": "0002-3456-7890",
    "amount": 30000.00,
    "remark": "租金轉帳"
}

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "java",
            "name": "Spring Boot - 啟動",
            "request": "launch",
            "mainClass": "com.bank.demo.BankingApiApplication",
            "projectName": "banking-api",
            "args": "--spring.profiles.active=dev",
            "vmArgs": "-Xmx512m -Xms256m"
        },
        {
            "type": "java",
            "name": "Spring Boot - Debug（遠端）",
            "request": "attach",
            "hostName": "localhost",
            "port": 5005
        },
        {
            "type": "java",
            "name": "JUnit Test - 當前檔案",
            "request": "launch",
            "mainClass": "",
            "projectName": "banking-api"
        }
    ]
}

// 在 transfer 方法中設定條件中斷點：
// 條件：amount.compareTo(new BigDecimal("50000")) > 0
// 只有轉帳金額超過 5 萬時才停住
public void transfer(TransferRequest request) {
    BigDecimal amount = request.getAmount();  // ← 在此設定條件中斷點
    // ...
}

/fix 我收到以下錯誤：
org.springframework.beans.factory.BeanCreationException: 
Error creating bean with name 'accountController': 
Unsatisfied dependency expressed through constructor parameter 0

/explain 為什麼這段程式碼會產生 NullPointerException？
#selection

在 Agent Mode 中：

修改 AccountController 的 /api/v1/accounts 端點，
新增分頁查詢功能（支援 page 和 size 參數），
修改完成後：
1. 重新啟動 Spring Boot
2. 使用整合式瀏覽器存取 http://localhost:8080/api/v1/accounts?page=0&size=10
3. 確認回傳結果包含 totalElements 欄位

# application.yml - 啟用 HTTPS
server:
  ssl:
    key-store: classpath:keystore.p12
    key-store-password: ${SSL_PASSWORD}
    key-store-type: PKCS12

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

<body>

<footer>

feat(account): 新增轉帳 API

- 實作 /api/v1/accounts/transfer 端點
- 包含餘額檢查與交易紀錄
- 新增對應的 JUnit 測試

Closes BANK-123

name: CI Pipeline

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

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    
    steps:
      - name: 取得原始碼
        uses: actions/checkout@v4

      - name: 設定 JDK 21
        uses: actions/setup-java@v4
        with:
          java-version: '21'
          distribution: 'temurin'
          cache: 'maven'

      - name: 編譯
        run: mvn compile -B

      - name: 執行測試
        run: mvn test -B

      - name: 產生測試覆蓋率報告
        run: mvn jacoco:report -B

      - name: 上傳覆蓋率報告
        uses: actions/upload-artifact@v4
        with:
          name: coverage-report
          path: target/site/jacoco/

      - name: 安全掃描（OWASP Dependency-Check）
        run: mvn dependency-check:check -B
        continue-on-error: true

      - name: 封裝 JAR
        run: mvn package -DskipTests -B

      - name: 上傳 JAR
        uses: actions/upload-artifact@v4
        with:
          name: app-jar
          path: target/*.jar

  code-quality:
    runs-on: ubuntu-latest
    needs: build-and-test
    
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0 # SonarQube 需要完整歷史

      - name: 設定 JDK 21
        uses: actions/setup-java@v4
        with:
          java-version: '21'
          distribution: 'temurin'
          cache: 'maven'

      - name: SonarQube 掃描
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
        run: |
          mvn sonar:sonar \
            -Dsonar.host.url=${{ secrets.SONAR_HOST_URL }} \
            -Dsonar.token=${{ secrets.SONAR_TOKEN }}

@workspace 幫我產生 GitHub Actions workflow，需求如下：
1. 觸發條件：push 到 main/develop、PR 到 main/develop
2. 步驟：
   - 使用 JDK 21 + Maven
   - 編譯 → 測試 → JaCoCo 覆蓋率報告
   - OWASP Dependency-Check
   - SonarQube 掃描
   - 打包 JAR 並上傳 Artifact
3. 環境變數使用 GitHub Secrets
4. 加入 Maven Cache 加速

# 在 PR 頁面或 VS Code PR Extension 中
@copilot 請 review 這個 PR，特別注意：
1. 安全性問題
2. 效能問題
3. 是否符合 copilot-instructions.md 規範

// settings.json
{
    "update.mode": "manual",
    "extensions.autoUpdate": false,
    "extensions.autoCheckUpdates": false
}

{
    "recommendations": [
        "vscjava.vscode-java-pack",
        "vmware.vscode-boot-dev-pack",
        "github.copilot",
        "github.copilot-chat",
        "humao.rest-client",
        "eamodio.gitlens",
        "sonarsource.sonarlint-vscode"
    ],
    "unwantedRecommendations": []
}

# 列出已安裝的 Extension
code --list-extensions --show-versions

# 匯出 Extension 清單
code --list-extensions > extensions-list.txt

# 從清單安裝（團隊統一）
Get-Content extensions-list.txt | ForEach-Object { code --install-extension $_ }

Model Picker → 選擇模型 → 點擊齒輪圖示
→ 統一選擇器中同時調整：
   • Context Size: Default / Large / Extended (1M)
   • Thinking Effort: Low / Medium / High

{
    // 啟用所有語言的 Copilot
    "github.copilot.enable": {
        "*": true
    },
    
    // Agent Mode 啟用
    "chat.agent.enabled": true,
    
    // Autopilot 預設權限（企業建議設為 auto-approve）
    "chat.permissions.default": "auto-approve",
    
    // Session Sync 啟用
    "chat.sessionSync.enabled": true,
    
    // 自訂指令檔
    "github.copilot.chat.codeGeneration.instructions": [
        { "file": ".github/copilot-instructions.md" }
    ]
}

## 命名規範
- 類別：PascalCase（例：AccountService）
- 方法/變數：camelCase（例：findByAccountNumber）
- 常數：UPPER_SNAKE_CASE（例：MAX_TRANSFER_AMOUNT）
- 套件：全小寫（例：com.bank.demo.service）

## 方法規範
- 單一方法不超過 30 行
- 參數不超過 4 個（超過使用 DTO）
- 必須有 JavaDoc 註解

## 例外處理
- Controller 層使用 @ControllerAdvice 統一處理
- Service 層使用自定義 BusinessException
- 禁止吞掉例外（catch 後不處理）

// settings.json
{
    "java.jdt.ls.vmargs": "-Xmx2g -Xms512m",
    "java.import.exclusions": [
        "**/node_modules/**",
        "**/.metadata/**",
        "**/archetype-resources/**"
    ],
    "files.watcherExclude": {
        "**/target/**": true,
        "**/.git/objects/**": true
    }
}

.authorizeHttpRequests(auth -> auth.anyRequest().permitAll())

// workspace.code-workspace
{
    "folders": [
        { "path": "../banking-api" },
        { "path": "../customer-api" },
        { "path": "../notification-service" }
    ]
}

- Java 版本：21
- Spring Boot 版本：3.4.x
- 禁止使用 javax.* 套件，使用 jakarta.*
- 使用 SecurityFilterChain 取代 WebSecurityConfigurerAdapter

// settings.json
{
    "http.proxy": "http://proxy.company.com:8080",
    "http.proxyStrictSSL": false,
    "github.copilot.advanced": {
        "authProvider": "github"
    }
}

<!-- pom.xml 加入 devtools -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

// settings.json
{
    "java.autobuild.enabled": true
}