# Prompt 範例：黑箱逆向分析

我有一個舊系統的功能觀察記錄如下：

## 畫面：客戶查詢
- 輸入：客戶編號（8位數字）、客戶姓名（模糊搜尋）
- 輸出：客戶基本資料列表（編號、姓名、電話、地址、開戶日期）
- 可進行：新增、修改、刪除、匯出 Excel
- 權限：僅主管可刪除

## 資料庫 Table
- CUSTOMER (CUST_ID, CUST_NAME, PHONE, ADDRESS, OPEN_DATE, STATUS)
- CUSTOMER_LOG (LOG_ID, CUST_ID, ACTION, ACTION_DATE, OPERATOR)

請幫我：
1. 推導出此功能的完整需求規格（Functional Requirements）
2. 識別可能的商業規則（Business Rules）
3. 產出 User Story 格式
4. 建議 Spring Boot 的 API 設計

# 將舊系統程式碼整理至 VS Code 工作區
# 建立統一的資料夾結構
legacy-system/
├── src/                  # 原始碼
│   ├── forms/           # VB Form / Delphi Form
│   ├── modules/         # 共用模組
│   ├── classes/         # 類別檔案
│   └── database/        # Stored Procedure / SQL
├── docs/                # 分析產出文件
│   ├── architecture/    # 架構文件
│   ├── api/            # API 規格
│   ├── data-model/     # 資料模型
│   └── requirements/   # 需求文件
└── analysis/           # 分析筆記

# Prompt：分析 VB6 模組

@workspace 請分析以下 VB6 程式碼，並說明：
1. 此模組的主要功能
2. 呼叫了哪些外部 API 或 COM 元件
3. 商業邏輯流程（用 Mermaid flowchart 表示）
4. 存取了哪些資料庫 Table
5. 錯誤處理機制
6. 隱含的商業規則

```vb
' === modCustomerMgmt.bas ===
Public Function GetCustomerByID(ByVal custID As String) As ADODB.Recordset
    Dim conn As New ADODB.Connection
    Dim rs As New ADODB.Recordset
    Dim sql As String
    
    conn.Open "Provider=SQLOLEDB;Data Source=PROD_DB;..."
    
    If Len(custID) <> 8 Then
        Err.Raise 9001, , "客戶編號必須為8碼"
    End If
    
    sql = "SELECT * FROM CUSTOMER WHERE CUST_ID = '" & custID & "' AND STATUS = 'A'"
    rs.Open sql, conn, adOpenKeyset, adLockReadOnly
    
    If rs.EOF Then
        Set GetCustomerByID = Nothing
    Else
        Set GetCustomerByID = rs
    End If
End Function
```

# Prompt：產出架構圖

請根據以下程式碼檔案清單，分析並產出系統架構圖（Mermaid 格式）：

檔案清單：
- frmMain.frm（主畫面）
- frmCustomer.frm（客戶管理）
- frmTransaction.frm（交易管理）
- modCustomer.bas（客戶模組）
- modTransaction.bas（交易模組）
- modReport.bas（報表模組）
- clsDBHelper.cls（資料庫工具）
- clsLogger.cls（日誌工具）

請產出：
1. 系統模組關係圖
2. 呼叫依賴圖
3. 資料流向圖

# Prompt：產出 API 設計

根據以下 Legacy 程式碼的功能分析：
- GetCustomerByID：依 ID 查詢客戶
- SearchCustomer：模糊搜尋客戶
- CreateCustomer：新增客戶
- UpdateCustomer：修改客戶
- DeleteCustomer：停用客戶（邏輯刪除）

請產出對應的 RESTful API 設計（OpenAPI 3.0 格式），包含：
1. HTTP Method & Path
2. Request / Response Schema
3. 狀態碼定義
4. 驗證規則

# Prompt：產出 ERD

以下是舊系統的資料庫 DDL：

CREATE TABLE CUSTOMER (
    CUST_ID     CHAR(8) NOT NULL,
    CUST_NAME   VARCHAR(50),
    PHONE       VARCHAR(20),
    ADDRESS     VARCHAR(200),
    OPEN_DATE   DATE,
    STATUS      CHAR(1) DEFAULT 'A',
    PRIMARY KEY (CUST_ID)
);

CREATE TABLE CUSTOMER_ACCOUNT (
    ACCT_NO     CHAR(14) NOT NULL,
    CUST_ID     CHAR(8) NOT NULL,
    ACCT_TYPE   CHAR(2),
    BALANCE     DECIMAL(15,2),
    OPEN_DATE   DATE,
    STATUS      CHAR(1),
    PRIMARY KEY (ACCT_NO),
    FOREIGN KEY (CUST_ID) REFERENCES CUSTOMER(CUST_ID)
);

請產出：
1. Mermaid ERD 圖
2. 欄位說明表
3. 建議的 JPA Entity 設計
4. 資料關係說明

# Prompt：模組優先排序分析

我正在對一個大型 Legacy 系統進行灰箱逆向。以下是系統模組清單：

| 模組 | 程式碼行數 | 使用頻率 | 相依模組數 | 最後修改 |
|------|----------|---------|-----------|---------|
| 客戶管理 | 15,000 | 高 | 3 | 2024-01 |
| 交易處理 | 45,000 | 極高 | 8 | 2025-06 |
| 報表系統 | 25,000 | 中 | 5 | 2023-03 |
| 帳務結算 | 35,000 | 中 | 6 | 2024-08 |
| 系統管理 | 8,000 | 低 | 2 | 2022-11 |

請幫我：
1. 建議遷移優先順序
2. 分析模組間依賴關係（Mermaid dependency graph）
3. 識別高風險模組
4. 提出風險緩解策略

-- 舊系統 Stored Procedure
CREATE PROCEDURE sp_CalcInterest
    @AccountNo CHAR(14),
    @CalcDate DATE
AS
BEGIN
    DECLARE @Balance DECIMAL(15,2)
    DECLARE @Rate DECIMAL(5,4)
    DECLARE @Interest DECIMAL(15,2)
    DECLARE @AcctType CHAR(2)
    
    SELECT @Balance = BALANCE, @AcctType = ACCT_TYPE 
    FROM ACCOUNT WHERE ACCT_NO = @AccountNo
    
    -- 依帳戶類別取利率
    IF @AcctType = '01'  -- 活期存款
        SET @Rate = 0.0125
    ELSE IF @AcctType = '02'  -- 定期存款
        SELECT @Rate = RATE FROM RATE_TABLE 
        WHERE ACCT_TYPE = '02' AND EFF_DATE <= @CalcDate
        ORDER BY EFF_DATE DESC
    ELSE IF @AcctType = '03'  -- 外幣存款
        SET @Rate = 0.0050
    
    -- 計息公式
    SET @Interest = @Balance * @Rate / 365
    
    -- 餘額低於 1000 不計息
    IF @Balance < 1000
        SET @Interest = 0
    
    INSERT INTO INTEREST_LOG (ACCT_NO, CALC_DATE, BALANCE, RATE, INTEREST)
    VALUES (@AccountNo, @CalcDate, @Balance, @Rate, @Interest)
    
    RETURN @Interest
END

請分析上述 Stored Procedure，推導出以下內容：

1. 功能需求（Functional Requirements）
2. 商業規則清單（Business Rules）
3. 資料需求（Data Requirements）
4. 例外處理需求
5. 以 User Story 格式撰寫需求

請使用企業級 SRS 格式輸出。

### FR-001：利息計算功能

**功能描述**：系統應根據帳戶類型、餘額及適用利率，自動計算每日利息。

**商業規則**：
- BR-001：活期存款（帳戶類型 01）適用固定利率 1.25%
- BR-002：定期存款（帳戶類型 02）適用利率表中生效日最近的利率
- BR-003：外幣存款（帳戶類型 03）適用固定利率 0.50%
- BR-004：帳戶餘額低於 1,000 時不計息
- BR-005：計息公式 = 餘額 × 利率 ÷ 365

**使用者故事**：
作為 帳務系統管理員
我要 系統每日自動計算各帳戶利息
以便 正確記錄利息收入並產出對帳資料

**驗收條件**：
- [ ] 活期存款按固定利率 1.25% 計算
- [ ] 定期存款從利率表取最新利率
- [ ] 餘額 < 1000 的帳戶利息為 0
- [ ] 計算結果記錄至利息日誌表

# Prompt：架構重建

我有一個 Legacy VB6 系統，結構如下：

Forms（畫面）：
- frmLogin.frm → 登入驗證
- frmMain.frm → 主選單
- frmCustomer.frm → 客戶管理（CRUD）
- frmAccount.frm → 帳戶管理
- frmTransaction.frm → 交易處理
- frmReport.frm → 報表查詢

Modules（底層模組）：
- modDB.bas → 資料庫連線
- modAuth.bas → 權限驗證
- modCustomer.bas → 客戶邏輯
- modAccount.bas → 帳戶邏輯
- modTransaction.bas → 交易邏輯
- modReport.bas → 報表邏輯
- modUtil.bas → 共用工具

請幫我：
1. 分析目前的架構（識別架構風格）
2. 提出目標 Clean Architecture 設計
3. 產出 Spring Boot 專案的 Package 結構
4. 定義各層的職責與介面

新系統 Spring Boot 專案結構（Clean Architecture）：

com.company.newapp/
├── adapter/                    # Interface Adapter Layer
│   ├── web/                   # Controller（REST API）
│   │   ├── CustomerController.java
│   │   ├── AccountController.java
│   │   └── TransactionController.java
│   ├── persistence/           # Repository 實作
│   │   ├── CustomerRepositoryImpl.java
│   │   ├── entity/           # JPA Entity
│   │   └── mapper/           # Entity ↔ Domain 轉換
│   └── security/             # Spring Security 設定
│       └── JwtAuthFilter.java
├── application/               # Application Layer（Use Cases）
│   ├── service/
│   │   ├── CustomerService.java
│   │   ├── AccountService.java
│   │   └── TransactionService.java
│   ├── dto/                  # Request / Response DTO
│   └── port/                 # Port 介面定義
│       ├── in/              # Driven Port（Use Case）
│       └── out/             # Driving Port（Repository）
├── domain/                    # Domain Layer（Business Logic）
│   ├── model/
│   │   ├── Customer.java
│   │   ├── Account.java
│   │   └── Transaction.java
│   ├── valueobject/
│   │   ├── AccountNumber.java
│   │   └── Money.java
│   └── rule/                 # 商業規則
│       ├── InterestCalculator.java
│       └── TransactionValidator.java
└── infrastructure/            # Infrastructure Layer
    ├── config/
    │   ├── SecurityConfig.java
    │   └── DatabaseConfig.java
    └── external/
        ├── NotificationService.java
        └── ReportGenerator.java

# 使用 Spring Initializr 建立專案
# 透過 Copilot CLI 或 VS Code Spring Boot Extension

# 必要 Dependencies：
# - Spring Web
# - Spring Data JPA
# - Spring Security
# - Spring Validation
# - Lombok
# - MapStruct
# - SpringDoc OpenAPI (Swagger)

# Prompt：將 VB 函式轉為 Spring Boot Service

以下是舊系統 VB 的客戶查詢邏輯：

```vb
Public Function SearchCustomer(ByVal name As String, _
                                ByVal phone As String) As Collection
    Dim sql As String
    sql = "SELECT * FROM CUSTOMER WHERE 1=1"
    
    If Len(name) > 0 Then
        sql = sql & " AND CUST_NAME LIKE '%" & name & "%'"
    End If
    
    If Len(phone) > 0 Then
        sql = sql & " AND PHONE = '" & phone & "'"
    End If
    
    sql = sql & " AND STATUS = 'A' ORDER BY CUST_NAME"
    
    ' ... execute and return
End Function
```

請轉換為 Spring Boot：
1. Repository（使用 Spring Data JPA + Specification）
2. Service（包含驗證邏輯）
3. Controller（RESTful API）
4. DTO（Request / Response）
5. 修正原始碼的 SQL Injection 問題

// === CustomerRepository.java ===
@Repository
public interface CustomerRepository extends JpaRepository<Customer, String>,
                                            JpaSpecificationExecutor<Customer> {
}

// === CustomerSpecification.java ===
public class CustomerSpecification {
    
    public static Specification<Customer> withFilters(String name, String phone) {
        return (root, query, cb) -> {
            List<Predicate> predicates = new ArrayList<>();
            
            // 只查有效客戶
            predicates.add(cb.equal(root.get("status"), "A"));
            
            if (StringUtils.hasText(name)) {
                predicates.add(cb.like(root.get("custName"), "%" + name + "%"));
            }
            
            if (StringUtils.hasText(phone)) {
                predicates.add(cb.equal(root.get("phone"), phone));
            }
            
            query.orderBy(cb.asc(root.get("custName")));
            return cb.and(predicates.toArray(new Predicate[0]));
        };
    }
}

// === CustomerService.java ===
@Service
@RequiredArgsConstructor
public class CustomerService {
    
    private final CustomerRepository customerRepository;
    
    public Page<CustomerResponse> searchCustomer(CustomerSearchRequest request, 
                                                  Pageable pageable) {
        Specification<Customer> spec = CustomerSpecification.withFilters(
            request.getName(), request.getPhone()
        );
        
        return customerRepository.findAll(spec, pageable)
                .map(CustomerMapper.INSTANCE::toResponse);
    }
}

// === CustomerController.java ===
@RestController
@RequestMapping("/api/v1/customers")
@RequiredArgsConstructor
public class CustomerController {
    
    private final CustomerService customerService;
    
    @GetMapping
    public ResponseEntity<Page<CustomerResponse>> searchCustomer(
            @Valid CustomerSearchRequest request,
            @PageableDefault(size = 20, sort = "custName") Pageable pageable) {
        
        return ResponseEntity.ok(customerService.searchCustomer(request, pageable));
    }
}

# Prompt：產生單元測試

請為以下 CustomerService.searchCustomer 方法產生完整的 JUnit 5 測試：

1. 正常查詢（有結果）
2. 空結果
3. 只輸入姓名
4. 只輸入電話
5. 分頁測試
6. 邊界條件（空字串、null）

使用 @MockBean 替換 Repository，使用 AssertJ 斷言。

@ExtendWith(MockitoExtension.class)
class CustomerServiceTest {

    @Mock
    private CustomerRepository customerRepository;

    @InjectMocks
    private CustomerService customerService;

    @Test
    @DisplayName("依姓名模糊查詢客戶 - 應返回匹配結果")
    void searchByName_shouldReturnMatchingCustomers() {
        // Given
        Customer customer = Customer.builder()
                .custId("00000001")
                .custName("王小明")
                .phone("0912345678")
                .status("A")
                .build();
        
        Page<Customer> page = new PageImpl<>(List.of(customer));
        when(customerRepository.findAll(any(Specification.class), any(Pageable.class)))
                .thenReturn(page);

        CustomerSearchRequest request = new CustomerSearchRequest();
        request.setName("王");

        // When
        Page<CustomerResponse> result = customerService.searchCustomer(
                request, PageRequest.of(0, 20));

        // Then
        assertThat(result.getContent()).hasSize(1);
        assertThat(result.getContent().get(0).getCustName()).isEqualTo("王小明");
        verify(customerRepository).findAll(any(Specification.class), any(Pageable.class));
    }

    @Test
    @DisplayName("查詢無結果 - 應返回空頁面")
    void searchWithNoResult_shouldReturnEmptyPage() {
        // Given
        when(customerRepository.findAll(any(Specification.class), any(Pageable.class)))
                .thenReturn(Page.empty());

        CustomerSearchRequest request = new CustomerSearchRequest();
        request.setName("不存在的名字");

        // When
        Page<CustomerResponse> result = customerService.searchCustomer(
                request, PageRequest.of(0, 20));

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

    @Test
    @DisplayName("不帶任何條件查詢 - 應返回所有有效客戶")
    void searchWithNoFilter_shouldReturnAllActive() {
        // Given
        List<Customer> customers = List.of(
                Customer.builder().custId("00000001").custName("王小明").status("A").build(),
                Customer.builder().custId("00000002").custName("李大華").status("A").build()
        );
        when(customerRepository.findAll(any(Specification.class), any(Pageable.class)))
                .thenReturn(new PageImpl<>(customers));

        CustomerSearchRequest request = new CustomerSearchRequest();

        // When
        Page<CustomerResponse> result = customerService.searchCustomer(
                request, PageRequest.of(0, 20));

        // Then
        assertThat(result.getContent()).hasSize(2);
    }
}

# === Dockerfile (Multi-Stage Build) ===
FROM eclipse-temurin:21-jdk-alpine AS builder
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests

FROM eclipse-temurin:21-jre-alpine
WORKDIR /app
COPY --from=builder /app/target/*.jar app.jar

# 安全性設定
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

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

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

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK 21
        uses: actions/setup-java@v4
        with:
          java-version: '21'
          distribution: 'temurin'

      - name: Build and Test
        run: mvn clean verify

      - name: SonarQube Scan
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
        run: mvn sonar:sonar

      - name: Build Docker Image
        if: github.ref == 'refs/heads/main'
        run: |
          docker build -t myapp:${{ github.sha }} .
          docker tag myapp:${{ github.sha }} registry.company.com/myapp:latest

      - name: Push to Registry
        if: github.ref == 'refs/heads/main'
        run: docker push registry.company.com/myapp:latest

# Copilot Chat Prompt

@workspace 請幫我分析這個 Legacy 專案，產出以下報告：

1. 技術棧摘要（語言、框架、版本）
2. 檔案結構清單（按模組分類）
3. 各模組的程式碼行數統計
4. 外部依賴清單（第三方元件、COM 元件）
5. 資料庫連線設定
6. 識別所有入口點（Main Form / Entry Point）

# Copilot Chat Prompt

請分析這個模組（modCustomer.bas），列出：

1. 所有 Public Function / Sub 的名稱與功能說明
2. 每個功能的參數與回傳值
3. 功能間的呼叫關係（Call Graph）
4. 存取的資料庫 Table 清單
5. 錯誤處理方式

# Copilot Chat Prompt

請分析此專案的資料庫 Schema，識別出：

1. 核心實體（Core Entity）及其關係
2. 值物件（Value Object）
3. 聚合根（Aggregate Root）— DDD 觀點
4. 產出 Mermaid Class Diagram
5. 產出 Mermaid ER Diagram

# Copilot Chat Prompt

根據以上分析的領域模型，請識別可能的 Bounded Context：

1. 各 Context 包含哪些 Entity
2. Context 之間的關係（Context Map）
3. 建議的微服務拆分方式（若適用）

# Copilot Chat Prompt

請根據我們分析的舊系統資訊，自動產出以下文件包：

## 1. 需求規格書（SRS）
- 系統概述
- 功能需求清單（按模組分類）
- 非功能需求（效能、安全、可用性）
- 商業規則清單
- 使用者故事

## 2. 系統設計書（SDS）
- 系統架構圖（C4 Model - System Context + Container）
- 模組設計（Class Diagram）
- API 設計（RESTful）
- 資料庫設計（ERD + 資料字典）
- 安全設計

各文件請使用 Markdown 格式，圖表使用 Mermaid。

# Copilot Chat / Agent Prompt

請幫我建立一個 Spring Boot 4.x 專案，需求如下：

專案名稱：customer-management-system
Java 版本：21
Build Tool：Maven

Dependencies：
- Spring Web
- Spring Data JPA
- Spring Security
- Spring Validation
- Spring Boot Actuator
- Lombok
- MapStruct
- SpringDoc OpenAPI
- Log4j2

架構：Clean Architecture
分層：
- adapter.web（Controller）
- adapter.persistence（JPA Repository）
- application.service（Use Case）
- application.dto（DTO）
- application.port（Port Interface）
- domain.model（Entity）
- domain.rule（Business Rules）
- infrastructure（Config）

請產出完整的 pom.xml 與基礎程式碼骨架。

分析 legacy-cms/ 目錄中的所有 VB6 原始碼，完成以下任務：

1. 掃描所有 .bas 和 .frm 檔案，建立模組功能清單
2. 分析每個模組的 Public 方法與商業規則
3. 識別所有資料庫操作（Table、SP）
4. 將分析結果寫入 docs/reverse-engineering-report.md
5. 產出 Mermaid 架構圖與 ERD
6. 建議 Spring Boot 4.x 對應的專案結構

請使用企業級格式輸出，表格對齊，圖表使用 Mermaid。

# Plan Agent Prompt

請為以下 Legacy 系統遷移規劃完整的實作計畫：

系統資訊：
- 程式碼：35,000 行 VB6
- 資料庫：SQL Server 2008（50 表、30 SP）
- 目標：Spring Boot 4.x + PostgreSQL 17

計畫需包含：
1. 遷移批次分組（按風險等級與依賴關係）
2. 每個批次的預估工時
3. 關鍵路徑識別
4. 風險項目與緩解方案
5. 里程碑定義

幫我把這個 VB 程式改成 Java

## 上下文
這是一個銀行帳務系統的 VB6 模組，負責客戶帳戶的利息計算。

## 任務
請將以下 VB6 函式轉換為 Spring Boot 4.x 的 Service 方法。

## 要求
1. 使用 Java 21 語法
2. 遵循 Clean Architecture 分層
3. 使用 JPA 取代 ADO 直接 SQL
4. 修正原始碼中的 SQL Injection 風險
5. 加入 JavaDoc 與 @Valid 驗證
6. 保留所有商業規則（標註在註解中）

## 原始碼
[貼上 VB 程式碼]

## 輸出格式
請分別產出：
- Entity
- Repository
- Service
- Controller
- DTO

# 角色：資深系統分析師
# 任務：分析 Legacy 程式碼模組

請分析以下 [VB6/Delphi/C#] 程式碼模組：

[貼上程式碼]

請產出：
1. **功能摘要**：此模組的主要功能（一句話）
2. **詳細流程**：商業邏輯步驟（Mermaid flowchart）
3. **商業規則**：所有 if/else/switch 中隱含的規則（BR-001 ~ BR-xxx）
4. **資料存取**：存取的 Table / SP 清單
5. **外部依賴**：呼叫的外部元件或 API
6. **安全風險**：識別潛在安全漏洞
7. **可維護性評估**：程式碼品質評分（1-10）及改善建議

# 任務：追蹤函式呼叫鏈

從入口點 [函式名稱] 開始，追蹤完整的呼叫鏈：

1. 列出所有被呼叫的函式（含檔案名稱）
2. 標示每個函式的層級深度
3. 標示資料庫操作點（CRUD）
4. 產出 Mermaid Sequence Diagram

格式：
入口函式 → 子函式A → 子函式B → DB操作

# 任務：資料流分析

分析此「[交易/功能]」的完整資料流：

1. 資料輸入點（使用者輸入 / 外部系統）
2. 資料轉換步驟
3. 資料驗證規則
4. 資料存入/更新的 Table
5. 資料輸出（畫面 / 報表 / 外部系統）

請產出 Mermaid Data Flow Diagram（DFD）。

# 角色：資深 Java 架構師
# 任務：VB6 → Spring Boot 轉換

## 原始 VB6 程式碼
[貼上 VB 程式碼]

## 轉換需求
1. **語言**：Java 21
2. **框架**：Spring Boot 4.x（或 3.x LTS）
3. **架構**：Clean Architecture
4. **ORM**：Spring Data JPA（取代 ADO）
5. **安全**：修正所有 SQL Injection、XSS 風險
6. **日誌**：使用 SLF4J + Log4j2
7. **驗證**：使用 Jakarta Validation
8. **例外**：使用自定義例外 + @ControllerAdvice

## 商業邏輯保留
- 請在 Java 程式碼中以 @BusinessRule 註解標示原始商業規則
- 如有不確定的邏輯，請加 @TODO 標記

## 輸出
請分層產出（附 JavaDoc）：
1. Domain Model (Entity)
2. Repository Interface
3. Service (Use Case)
4. Controller (REST API)
5. DTO (Request/Response)

# 角色：資料庫和 Java 專家
# 任務：Stored Procedure → Spring Boot Service

## 原始 SP
[貼上 Stored Procedure]

## 轉換原則
1. SP 中的 SQL → JPA Repository 方法
2. SP 中的商業邏輯 → Service 方法
3. SP 中的資料驗證 → Jakarta Validation + 自定義 Validator
4. SP 中的錯誤處理 → 自定義 Exception
5. 暫存表邏輯 → Java Collection 處理
6. 游標邏輯 → Stream API

## 注意
- 保持交易完整性（@Transactional）
- 處理並發（樂觀鎖 / 悲觀鎖）
- 效能考量（N+1 問題、Batch 操作）

# 角色：跨平台資深工程師
# 任務：C# .NET → Java Spring Boot 轉換

## 原始 C# 程式碼
[貼上 C# 程式碼]

## 對照轉換規則
| C# | Java |
|------|------|
| LINQ | Stream API |
| Entity Framework | Spring Data JPA |
| ASP.NET Controller | @RestController |
| Dependency Injection | Spring @Autowired / Constructor Injection |
| async/await | CompletableFuture / @Async |
| ILogger | SLF4J Logger |
| DataAnnotation | Jakarta Validation |

## 輸出
依 Spring Boot 最佳實務產出轉換後的 Java 程式碼，
附上轉換決策說明。

# 任務：產出 RESTful API 文件

根據以下 Legacy 函式清單，設計對應的 RESTful API：

Legacy 函式：
1. GetCustomerByID(custID) → 單一客戶查詢
2. SearchCustomer(name, phone, page) → 客戶搜尋
3. CreateCustomer(custData) → 新增客戶
4. UpdateCustomer(custID, custData) → 修改客戶
5. DeleteCustomer(custID) → 停用客戶
6. GetCustomerAccounts(custID) → 查詢客戶帳戶
7. ExportCustomerReport(criteria) → 匯出報表

請產出：
1. API 一覽表（Method / Path / 說明）
2. 每個 API 的 Request / Response Schema（JSON）
3. 錯誤碼定義
4. OpenAPI 3.0 YAML 片段

# 任務：產出系統架構設計文件（SDS）

根據逆向分析結果，產出以下架構文件：

## 系統概述
[簡述系統功能]

## 需要產出
1. C4 Model（Context / Container / Component 三層）— 使用 Mermaid
2. 部署架構圖
3. 資料庫架構（ERD）
4. 安全架構
5. 模組相依關係圖
6. 技術選型理由

## 格式
- 每個圖表使用 Mermaid
- 每個設計決策需附上理由
- 標示風險點與緩解方案

# 任務：生成 Characterization Test

為以下商業邏輯生成「特徵測試」，用於記錄舊系統的實際行為：

## 商業邏輯
[貼上 Service 方法或商業規則]

## 測試要求
1. 使用 JUnit 5 + AssertJ
2. 使用 @ParameterizedTest 覆蓋所有分支
3. 覆蓋正常路徑、邊界值、異常路徑
4. 每個測試附上 @DisplayName（中文說明）
5. 測試資料覆蓋所有商業規則

## 測試案例需包含
- 正常案例（Happy Path）
- 邊界值（Boundary）
- 異常案例（Error Path）
- 並發案例（如適用）

# 任務：生成 API 整合測試

為以下 REST API 產出完整整合測試：

## API
[貼上 Controller 程式碼]

## 測試要求
1. 使用 @SpringBootTest + @AutoConfigureMockMvc
2. 使用 @TestContainers 模擬資料庫
3. 測試完整的 HTTP 請求/回應
4. 驗證 HTTP Status Code
5. 驗證 Response Body（JSON Path）
6. 驗證資料庫狀態變化

## 測試案例
- 成功建立資源 → 201
- 查詢存在的資源 → 200
- 查詢不存在的資源 → 404
- 無效輸入 → 400
- 未授權 → 401
- 權限不足 → 403

# === 逆向工程分析模板 ===

## 角色
你是資深 [語言] 工程師與 Java 架構師。

## 上下文
這是 [系統名稱] 的 [模組名稱]，功能為 [一句話描述]。

## 原始碼
[貼上程式碼]

## 分析任務
請產出：
1. 功能摘要（50字以內）
2. 詳細流程（Mermaid flowchart）
3. 商業規則清單（BR-xxx）
4. 資料庫操作清單
5. 安全風險識別
6. 對應的 Spring Boot 設計建議

## 輸出格式
使用 Markdown，圖表使用 Mermaid。

# === 批次程式碼轉換模板 ===

## 轉換目標
源語言：[VB6 / C# / Delphi / COBOL]
目標語言：Java 21 + Spring Boot 4.x（或 3.x）

## 轉換規則
- [源語言特性] → [Java 對應]
- [源語言特性] → [Java 對應]
（根據語言調整）

## 品質要求
- [ ] 遵循 Clean Architecture
- [ ] 包含 JavaDoc
- [ ] 包含 Validation
- [ ] 修正安全漏洞
- [ ] 保留商業規則（標註）
- [ ] 產出對應的單元測試

## 原始碼
[貼上程式碼]

# .github/copilot-instructions.md — 逆向工程專案專用

## 專案背景
本專案正在將 VB6 客戶管理系統遷移至 Spring Boot 4.x。

## 程式碼規範
1. 目標框架：Spring Boot 4.x + Java 21
2. 架構風格：Clean Architecture（adapter / application / domain / infrastructure）
3. ORM：Spring Data JPA
4. 驗證：Jakarta Validation
5. 日誌：SLF4J + Log4j2
6. 安全：Spring Security + JWT

## 逆向工程規範
1. 分析 Legacy 程式碼時，必須識別並標註所有商業規則（使用 @BusinessRule 註解）
2. 所有 AI 產出必須包含「轉換決策說明」
3. 轉換後的程式碼必須修正原始碼中的安全漏洞
4. 使用 Mermaid 格式產出所有圖表
5. 目的碼必須包含 JavaDoc（繁體中文）

## 命名慣例
- Package：com.company.cms
- REST API 路徑：/api/v1/{resource}
- 資料庫表名：小寫底線（customers, customer_accounts）
- Entity 類名：PascalCase 單數（Customer, Account）

# .github/copilot/skills/analyze-legacy-code.md
---
name: analyze-legacy-code
description: 分析 Legacy 程式碼並產出結構化報告
---

## 指令
當使用者要求分析 Legacy 程式碼時：
1. 先識別程式語言（VB6 / Delphi / C# / COBOL / 舊版 Java）
2. 掃描所有 Public 方法與全域變數
3. 識別商業規則（所有 if/switch 條件）
4. 列出資料庫操作（Table + CRUD 類型）
5. 識別安全風險（SQL Injection、硬編碼密碼等）
6. 產出 Mermaid 架構圖
7. 建議 Spring Boot 對應設計

## 輸出格式
使用 Markdown，包含：模組摘要表、商業規則清單、安全風險清單、架構圖。

# Agent Mode — 全模組逆向分析

## 目標
對 legacy-cms/ 目錄中的 VB6 專案進行完整逆向分析，
所有結果寫入 docs/analysis/ 目錄。

## 約束條件
- 輸出格式：Markdown + Mermaid
- 語言：繁體中文
- 架構設計目標：Spring Boot 4.x + Clean Architecture
- 安全標準：OWASP Top 10 2025

## 預期產出
1. docs/analysis/module-inventory.md — 模組清冊
2. docs/analysis/business-rules.md — 商業規則清冊
3. docs/analysis/architecture.md — 系統架構圖
4. docs/analysis/erd.md — 資料庫 ERD
5. docs/analysis/security-audit.md — 安全風險報告
6. docs/analysis/migration-plan.md — 遷移計畫

請依序完成以上 6 個檔案。

# Agent Mode — 模組自動遷移

## 目標
將 legacy-cms/Modules/modCustomer.bas 中的客戶管理功能，
遷移為 Spring Boot 4.x 的完整實作。

## 約束條件
- 遵循 Clean Architecture 四層架構
- 使用 Spring Data JPA（非原生 SQL）
- 所有商業規則標註 @BusinessRule
- 修正所有 SQL Injection 漏洞
- 包含 JavaDoc（繁體中文）
- 包含 JUnit 5 測試（覆蓋率目標 80%）

## 預期產出
在 src/main/java/com/company/cms/ 下建立：
1. domain/model/Customer.java
2. domain/rule/CustomerValidator.java
3. application/service/CustomerService.java
4. application/dto/CustomerRequest.java
5. application/dto/CustomerResponse.java
6. adapter/web/CustomerController.java
7. adapter/persistence/CustomerRepository.java
8. adapter/persistence/CustomerEntity.java

在 src/test/java/com/company/cms/ 下建立：
9. application/service/CustomerServiceTest.java
10. adapter/web/CustomerControllerTest.java

完成後執行 mvn compile 確認無編譯錯誤。

// === Domain Layer: Business Rule ===
public class InterestCalculator {
    
    /**
     * 計算帳戶利息
     * @BusinessRule BR-001: 活期利率 1.25%
     * @BusinessRule BR-004: 餘額 < 1000 不計息
     */
    public Money calculateDailyInterest(Account account, InterestRate rate) {
        if (account.getBalance().isLessThan(Money.of(1000))) {
            return Money.ZERO;
        }
        
        BigDecimal dailyRate = rate.getAnnualRate()
                .divide(BigDecimal.valueOf(365), 10, RoundingMode.HALF_UP);
        
        return account.getBalance().multiply(dailyRate);
    }
}

// === Application Layer: Use Case ===
@Service
@RequiredArgsConstructor
@Transactional
public class CalculateInterestUseCase {
    
    private final AccountPort accountPort;
    private final InterestRatePort ratePort;
    private final InterestLogPort logPort;
    private final InterestCalculator calculator;
    
    public InterestResult execute(String accountNo, LocalDate calcDate) {
        Account account = accountPort.findByAccountNo(accountNo)
                .orElseThrow(() -> new AccountNotFoundException(accountNo));
        
        InterestRate rate = ratePort.findEffectiveRate(
                account.getAccountType(), calcDate);
        
        Money interest = calculator.calculateDailyInterest(account, rate);
        
        InterestLog log = InterestLog.create(account, calcDate, rate, interest);
        logPort.save(log);
        
        return InterestResult.of(account, interest);
    }
}

// === Adapter Layer: Controller ===
@RestController
@RequestMapping("/api/v1/interest")
@RequiredArgsConstructor
public class InterestController {
    
    private final CalculateInterestUseCase calculateInterest;
    
    @PostMapping("/calculate")
    public ResponseEntity<InterestResponse> calculate(
            @Valid @RequestBody InterestRequest request) {
        
        InterestResult result = calculateInterest.execute(
                request.getAccountNo(), request.getCalcDate());
        
        return ResponseEntity.ok(InterestMapper.INSTANCE.toResponse(result));
    }
}

-- V001__create_customer_table.sql
CREATE TABLE customers (
    id          VARCHAR(8)   PRIMARY KEY,
    name        VARCHAR(50)  NOT NULL,
    phone       VARCHAR(20),
    address     VARCHAR(200),
    open_date   DATE         NOT NULL DEFAULT CURRENT_DATE,
    status      VARCHAR(10)  NOT NULL DEFAULT 'ACTIVE',
    created_at  TIMESTAMP    NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at  TIMESTAMP    NOT NULL DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX idx_customers_name ON customers(name);
CREATE INDEX idx_customers_status ON customers(status);

COMMENT ON TABLE customers IS '客戶主檔';
COMMENT ON COLUMN customers.id IS '客戶編號（8位）';
COMMENT ON COLUMN customers.status IS '狀態：ACTIVE/INACTIVE/CLOSED';

-- V002__migrate_customer_data.sql
-- 從舊系統匯入資料
INSERT INTO customers (id, name, phone, address, open_date, status)
SELECT 
    CUST_ID,
    CUST_NAME,
    PHONE,
    ADDRESS,
    OPEN_DATE,
    CASE STATUS 
        WHEN 'A' THEN 'ACTIVE'
        WHEN 'I' THEN 'INACTIVE'
        WHEN 'C' THEN 'CLOSED'
        ELSE 'ACTIVE'
    END
FROM legacy_customer_import;

✅ 建立 AI 產出審查流程：
1. AI 產出 → Code Review（至少 2 人）
2. 特別檢查：商業邏輯、安全性、效能
3. 執行自動化測試驗證
4. 與舊系統行為比對

## 真實案例：銀行帳務系統
舊系統中有一段「看似無用」的程式碼：

If custType = "VIP" And dayOfMonth = 25 Then
    balance = balance + (balance * 0.001)
End If

此段程式碼實際上是：每月 25 日為 VIP 客戶自動加計 0.1% 回饋金。
由於未記錄在任何文件中，逆向工程時差點被跳過。

教訓：所有看似無用的程式碼都需要調查確認。

# Prompt：安全性分析

請對以下程式碼進行安全性審查（參考 OWASP Top 10 2025）：

[貼上程式碼]

請檢查並列出：
1. 所有 SQL Injection 風險點
2. XSS 風險點
3. 認證/授權漏洞
4. 敏感資料洩露風險
5. 加密方式是否安全
6. 輸入驗證是否完善
7. 嚴重程度評級（Critical / High / Medium / Low）
8. 修正建議（含程式碼）

# 企業級 Copilot 政策設定範例
copilot_policies:
  # 程式碼建議
  code_suggestions: enabled
  
  # 排除特定檔案（避免 AI 存取敏感資料）
  content_exclusion:
    - "**/.env*"
    - "**/secrets/**"
    - "**/config/credentials/**"
    - "**/sql/production/**"
  
  # Agent 功能控制
  agent_mode: enabled
  cloud_agent: enabled_with_approval  # 需管理者核准
  
  # 稽核日誌
  audit_logging: enabled
  
  # 使用量追蹤
  usage_metrics: enabled

feat(customer): 新增客戶查詢 API — 從 VB6 modCustomer.bas 遷移

- 使用 Copilot Agent Mode 輔助轉換 SearchCustomer 函式
- 修正原始 SQL Injection 漏洞（SEC-001）
- 保留商業規則 BR-001~BR-005
- 新增 JUnit 5 測試（覆蓋率 85%）

AI-Assisted: GitHub Copilot (Agent Mode)
Reviewed-By: senior-dev@company.com
Legacy-Source: legacy-cms/Modules/modCustomer.bas

專案結構：
legacy-cms/
├── Forms/
│   ├── frmMain.frm           # 主畫面
│   ├── frmLogin.frm          # 登入
│   ├── frmCustomer.frm       # 客戶管理
│   ├── frmCustSearch.frm     # 客戶查詢
│   ├── frmAccount.frm        # 帳戶管理
│   └── frmReport.frm         # 報表
├── Modules/
│   ├── modDB.bas             # 資料庫連線
│   ├── modCustomer.bas       # 客戶邏輯
│   ├── modAccount.bas        # 帳戶邏輯
│   ├── modAuth.bas           # 權限
│   └── modUtil.bas           # 工具
├── Classes/
│   └── clsLogger.cls         # 日誌
└── SQL/
    ├── sp_GetCustomer.sql
    ├── sp_SearchCustomer.sql
    ├── sp_CreateCustomer.sql
    └── sp_UpdateCustomer.sql

' === frmCustSearch.frm ===
Private Sub cmdSearch_Click()
    Dim conn As New ADODB.Connection
    Dim rs As New ADODB.Recordset
    Dim sql As String
    
    ' 連線資料庫
    conn.Open "Provider=SQLOLEDB;Data Source=BANKDB01;" & _
              "Initial Catalog=CMS;User ID=sa;Password=Bank#2005;"
    
    ' 組合 SQL
    sql = "SELECT c.CUST_ID, c.CUST_NAME, c.PHONE, c.ID_NO, " & _
          "c.ADDRESS, c.OPEN_DATE, c.STATUS, " & _
          "(SELECT COUNT(*) FROM ACCOUNT WHERE CUST_ID = c.CUST_ID) AS ACCT_CNT " & _
          "FROM CUSTOMER c WHERE 1=1"
    
    If txtCustID.Text <> "" Then
        sql = sql & " AND c.CUST_ID = '" & txtCustID.Text & "'"
    End If
    
    If txtCustName.Text <> "" Then
        sql = sql & " AND c.CUST_NAME LIKE '%" & txtCustName.Text & "%'"
    End If
    
    If txtIDNo.Text <> "" Then
        sql = sql & " AND c.ID_NO = '" & txtIDNo.Text & "'"
    End If
    
    sql = sql & " AND c.STATUS <> 'D'"  ' 排除已刪除
    sql = sql & " ORDER BY c.CUST_NAME"
    
    rs.Open sql, conn, adOpenStatic, adLockReadOnly
    
    ' 填充列表
    lvResult.ListItems.Clear
    Do While Not rs.EOF
        Dim li As ListItem
        Set li = lvResult.ListItems.Add(, , rs("CUST_ID"))
        li.SubItems(1) = rs("CUST_NAME") & ""
        li.SubItems(2) = rs("PHONE") & ""
        li.SubItems(3) = rs("ID_NO") & ""
        li.SubItems(4) = rs("ACCT_CNT") & ""
        li.SubItems(5) = IIf(rs("STATUS") = "A", "有效", "停用")
        rs.MoveNext
    Loop
    
    rs.Close
    conn.Close
    
    lblCount.Caption = "共 " & lvResult.ListItems.Count & " 筆"
End Sub

@workspace 請分析以上 VB6 程式碼（frmCustSearch.frm 的 cmdSearch_Click），
並產出以下報告：

1. 功能描述
2. 商業規則
3. 安全漏洞
4. 效能問題
5. 建議的 Spring Boot API 設計

## 分析報告：客戶查詢功能

### 1. 功能描述
多條件客戶搜尋功能，支援依客戶編號（精準）、姓名（模糊）、
身分證號（精準）查詢，排除已刪除客戶，並顯示各客戶帳戶數量。

### 2. 商業規則
- BR-001：查詢排除 STATUS = 'D'（已刪除）的客戶
- BR-002：客戶編號為精準查詢
- BR-003：姓名為模糊查詢（前後 LIKE）
- BR-004：身分證號為精準查詢
- BR-005：結果需顯示關聯帳戶數量

### 3. 安全漏洞 🔴
- SQL-001：嚴重 SQL Injection（字串直接拼接）
- SEC-001：資料庫密碼硬編碼（sa/Bank#2005）
- SEC-002：使用 sa 帳號連線（最高權限）
- SEC-003：身分證號等敏感資料未脫敏顯示

### 4. 效能問題
- PERF-001：子查詢 COUNT(*) 每次執行（N+1 問題）
- PERF-002：無分頁（大量資料時效能低落）
- PERF-003：每次查詢都建立新連線（無連線池）

### 5. 建議的 Spring Boot API 設計
GET /api/v1/customers?custId={}&name={}&idNo={}&page=0&size=20

@Entity
@Table(name = "customers")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Customer {
    
    @Id
    @Column(name = "cust_id", length = 8)
    private String custId;
    
    @Column(name = "cust_name", length = 50, nullable = false)
    private String custName;
    
    @Column(length = 20)
    private String phone;
    
    @Column(name = "id_no", length = 10)
    private String idNo;
    
    @Column(length = 200)
    private String address;
    
    @Column(name = "open_date", nullable = false)
    private LocalDate openDate;
    
    @Enumerated(EnumType.STRING)
    @Column(length = 10, nullable = false)
    private CustomerStatus status = CustomerStatus.ACTIVE;
    
    @OneToMany(mappedBy = "customer", fetch = FetchType.LAZY)
    private List<Account> accounts = new ArrayList<>();
    
    // === 商業規則方法 ===
    
    /** @BusinessRule BR-002: 客戶編號必須8碼數字 */
    public static Customer create(String custId, String custName, String idNo) {
        if (!custId.matches("\\d{8}")) {
            throw new InvalidCustomerIdException(custId);
        }
        Customer customer = new Customer();
        customer.custId = custId;
        customer.custName = custName;
        customer.idNo = idNo;
        customer.openDate = LocalDate.now();
        return customer;
    }
    
    /** @BusinessRule BR-001: 不可查詢已刪除客戶 */
    public boolean isQueryable() {
        return this.status != CustomerStatus.DELETED;
    }
}

@Repository
public interface CustomerRepository extends JpaRepository<Customer, String>,
                                            JpaSpecificationExecutor<Customer> {
    
    /** @BusinessRule BR-003: 身分證號不可重複 */
    boolean existsByIdNo(String idNo);
    
    @Query("SELECT c FROM Customer c LEFT JOIN FETCH c.accounts " +
           "WHERE c.custId = :custId AND c.status <> 'DELETED'")
    Optional<Customer> findActiveById(@Param("custId") String custId);
}

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class CustomerQueryService {
    
    private final CustomerRepository customerRepository;
    
    /**
     * 客戶多條件查詢
     * @BusinessRule BR-001: 排除已刪除客戶
     */
    public Page<CustomerSearchResponse> search(
            CustomerSearchRequest request, Pageable pageable) {
        
        Specification<Customer> spec = Specification.where(null);
        
        // BR-001：排除已刪除
        spec = spec.and((root, query, cb) -> 
            cb.notEqual(root.get("status"), CustomerStatus.DELETED));
        
        if (StringUtils.hasText(request.getCustId())) {
            spec = spec.and((root, query, cb) -> 
                cb.equal(root.get("custId"), request.getCustId()));
        }
        
        if (StringUtils.hasText(request.getName())) {
            spec = spec.and((root, query, cb) -> 
                cb.like(root.get("custName"), "%" + request.getName() + "%"));
        }
        
        if (StringUtils.hasText(request.getIdNo())) {
            spec = spec.and((root, query, cb) -> 
                cb.equal(root.get("idNo"), request.getIdNo()));
        }
        
        return customerRepository.findAll(spec, pageable)
                .map(this::toResponse);
    }
    
    private CustomerSearchResponse toResponse(Customer customer) {
        return CustomerSearchResponse.builder()
                .custId(customer.getCustId())
                .custName(customer.getCustName())
                .phone(customer.getPhone())
                .idNo(maskIdNo(customer.getIdNo()))  // 脫敏處理
                .accountCount(customer.getAccounts().size())
                .status(customer.getStatus().getDisplayName())
                .build();
    }
    
    /** 安全性：身分證號脫敏 */
    private String maskIdNo(String idNo) {
        if (idNo == null || idNo.length() < 4) return "****";
        return idNo.substring(0, 3) + "****" + idNo.substring(idNo.length() - 3);
    }
}

@RestController
@RequestMapping("/api/v1/customers")
@RequiredArgsConstructor
@Tag(name = "客戶管理", description = "客戶資料查詢與管理 API")
public class CustomerController {
    
    private final CustomerQueryService customerQueryService;
    
    @GetMapping
    @Operation(summary = "客戶查詢", description = "支援多條件組合查詢")
    public ResponseEntity<Page<CustomerSearchResponse>> searchCustomers(
            @Valid CustomerSearchRequest request,
            @PageableDefault(size = 20, sort = "custName") Pageable pageable) {
        
        return ResponseEntity.ok(
            customerQueryService.search(request, pageable));
    }
}

@Data
public class CustomerSearchRequest {
    
    @Size(max = 8, message = "客戶編號最多8碼")
    @Pattern(regexp = "^\\d*$", message = "客戶編號僅限數字")
    private String custId;
    
    @Size(max = 50, message = "姓名最多50字")
    private String name;
    
    @Size(max = 10, message = "身分證號最多10碼")
    private String idNo;
}

@Data
@Builder
public class CustomerSearchResponse {
    private String custId;
    private String custName;
    private String phone;
    private String idNo;     // 已脫敏
    private Integer accountCount;
    private String status;
}

// === CustomerServlet.java (Java 1.4 + Servlet 2.3) ===
public class CustomerServlet extends HttpServlet {
    
    public void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        
        String action = req.getParameter("action");
        Connection conn = null;
        
        try {
            Class.forName("oracle.jdbc.driver.OracleDriver");
            conn = DriverManager.getConnection(
                "jdbc:oracle:thin:@proddb:1521:ORCL", "app_user", "app_pass");
            
            if ("search".equals(action)) {
                String name = req.getParameter("name");
                String sql = "SELECT * FROM CUSTOMER WHERE CUST_NAME LIKE '%" 
                            + name + "%'";
                Statement stmt = conn.createStatement();
                ResultSet rs = stmt.executeQuery(sql);
                
                ArrayList list = new ArrayList();
                while (rs.next()) {
                    HashMap map = new HashMap();
                    map.put("id", rs.getString("CUST_ID"));
                    map.put("name", rs.getString("CUST_NAME"));
                    map.put("phone", rs.getString("PHONE"));
                    list.add(map);
                }
                
                req.setAttribute("customers", list);
                req.getRequestDispatcher("/WEB-INF/customer.jsp").forward(req, resp);
                
            } else if ("delete".equals(action)) {
                String id = req.getParameter("id");
                String sql = "DELETE FROM CUSTOMER WHERE CUST_ID = '" + id + "'";
                Statement stmt = conn.createStatement();
                stmt.executeUpdate(sql);
                resp.sendRedirect("CustomerServlet?action=search");
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new ServletException(e);
        } finally {
            try { if (conn != null) conn.close(); } catch (Exception e) {}
        }
    }
}

# Prompt

請將上述 Java Servlet 程式碼分析並轉換為 Spring Boot 4.x：

問題識別：
1. SQL Injection（字串拼接）
2. 硬編碼資料庫密碼
3. 物理刪除（應改邏輯刪除）
4. 無型別安全（Raw Type ArrayList/HashMap）
5. Exception 處理不當（直接 printStackTrace）
6. 無資源管理（Statement/ResultSet 未關閉）

轉換要求：
- 使用 Spring Data JPA
- 使用 @RestController（前後端分離）
- 使用 @Valid 驗證
- 刪除改為邏輯刪除
- 適當的例外處理（@ControllerAdvice）

// === CustomerController.java ===
@RestController
@RequestMapping("/api/v1/customers")
@RequiredArgsConstructor
public class CustomerController {
    
    private final CustomerService customerService;
    
    @GetMapping
    public ResponseEntity<Page<CustomerDto>> search(
            @RequestParam(required = false) String name,
            Pageable pageable) {
        return ResponseEntity.ok(customerService.search(name, pageable));
    }
    
    @DeleteMapping("/{id}")
    @PreAuthorize("hasRole('MANAGER')")  // BR-008: 僅主管可刪除
    public ResponseEntity<Void> delete(@PathVariable String id) {
        customerService.softDelete(id);  // 邏輯刪除
        return ResponseEntity.noContent().build();
    }
}

// === CustomerService.java ===
@Service
@RequiredArgsConstructor
@Transactional
public class CustomerService {
    
    private static final Logger log = LoggerFactory.getLogger(CustomerService.class);
    private final CustomerRepository repository;
    
    @Transactional(readOnly = true)
    public Page<CustomerDto> search(String name, Pageable pageable) {
        if (StringUtils.hasText(name)) {
            return repository.findByNameContainingAndStatusNot(
                name, CustomerStatus.DELETED, pageable)
                .map(CustomerMapper.INSTANCE::toDto);
        }
        return repository.findByStatusNot(CustomerStatus.DELETED, pageable)
                .map(CustomerMapper.INSTANCE::toDto);
    }
    
    /** 邏輯刪除（取代物理刪除） */
    public void softDelete(String id) {
        Customer customer = repository.findById(id)
                .orElseThrow(() -> new CustomerNotFoundException(id));
        customer.markAsDeleted();
        repository.save(customer);
        log.info("客戶 {} 已被邏輯刪除", id);
    }
}

// .vscode/settings.json
{
    "java.configuration.runtimes": [
        {
            "name": "JavaSE-21",
            "path": "/path/to/jdk-21",
            "default": true
        }
    ],
    "java.compile.nullAnalysis.mode": "automatic",
    "editor.formatOnSave": true,
    "github.copilot.enable": {
        "*": true,
        "markdown": true,
        "plaintext": true,
        "sql": true
    },
    "github.copilot.chat.localeOverride": "zh-TW"
}

// .vscode/settings.json (Legacy + New 混合工作區)
{
    "files.associations": {
        "*.bas": "vb",
        "*.frm": "vb",
        "*.cls": "vb",
        "*.pas": "pascal",
        "*.dfm": "pascal"
    },
    "files.encoding": "utf8",
    "files.autoGuessEncoding": true
}

Step 1：先讓 Copilot 分析檔案結構
> @workspace 列出此專案的所有檔案結構，按模組分類

Step 2：逐模組分析
> #file:modCustomer.bas 分析此模組的所有 Public 方法

Step 3：深入特定函式
> 分析 GetCustomerByID 函式的完整邏輯流程

Step 4：跨模組追蹤
> GetCustomerByID 呼叫了哪些其他模組的函式？

第一輪：「分析 CUSTOMER 表的 Schema」
第二輪：「根據上述 Schema，分析 modCustomer.bas 如何操作此表」
第三輪：「根據以上分析，設計對應的 Spring Boot Entity + Repository」
第四輪：「根據以上設計，產出完整的 CRUD API」

# 使用 Copilot CLI 快速分析專案結構
gh copilot suggest "分析此目錄下所有 VB 檔案的模組結構"

# 批次產出分析報告
gh copilot suggest "寫一個 script 掃描所有 .bas 檔案，列出 Public Function 清單"

# 快速建立 Spring Boot 專案
gh copilot suggest "使用 Spring Initializr CLI 建立含 JPA 和 Security 的專案"

# 程式碼統計
gh copilot suggest "統計此目錄下各語言的程式碼行數"

# 使用 Copilot Agent 進行自動化分析

在 VS Code 中啟用 Agent Mode（@workspace）：

Prompt：
「請自動分析此 Legacy 專案（legacy-cms/），並依序完成：
1. 掃描所有程式檔案，產出模組清單
2. 識別所有資料庫操作（Table / SP）
3. 抽取所有商業規則
4. 產出系統架構圖（Mermaid）
5. 產出 ERD（Mermaid）
6. 建議 Spring Boot 專案結構
7. 將結果整理為 Markdown 報告

請將報告存為 docs/reverse-engineering-report.md」

# sonar-project.properties（舊系統 VB6 分析）
sonar.projectKey=legacy-cms
sonar.projectName=Legacy CMS Analysis
sonar.sources=.
sonar.language=vbnet
sonar.sourceEncoding=big5

# SonarQube Quality Gate 設定
quality_gate:
  conditions:
    - metric: new_coverage
      operator: LT
      value: 80          # 新程式碼覆蓋率 >= 80%
    - metric: new_bugs
      operator: GT
      value: 0           # 不允許新 Bug
    - metric: new_vulnerabilities
      operator: GT
      value: 0           # 不允許新安全漏洞
    - metric: new_code_smells
      operator: GT
      value: 10          # 新 Code Smell <= 10
    - metric: new_duplicated_lines_density
      operator: GT
      value: 3           # 重複率 <= 3%

<!-- pom.xml -->
<plugin>
    <groupId>org.sonarsource.scanner.maven</groupId>
    <artifactId>sonar-maven-plugin</artifactId>
    <version>4.0.0.4121</version>
</plugin>

# 執行掃描
mvn clean verify sonar:sonar \
  -Dsonar.host.url=http://sonarqube:9000 \
  -Dsonar.token=${SONAR_TOKEN}

<!-- pom.xml -->
<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.6.0</version>
</dependency>

// OpenAPI 設定
@Configuration
public class OpenApiConfig {
    
    @Bean
    public OpenAPI customOpenAPI() {
        return new OpenAPI()
            .info(new Info()
                .title("客戶管理系統 API")
                .description("由 Legacy VB6 系統逆向工程重建的 RESTful API")
                .version("1.0.0")
                .contact(new Contact()
                    .name("架構團隊")
                    .email("arch@company.com")))
            .addSecurityItem(new SecurityRequirement().addList("JWT"))
            .components(new Components()
                .addSecuritySchemes("JWT", new SecurityScheme()
                    .type(SecurityScheme.Type.HTTP)
                    .scheme("bearer")
                    .bearerFormat("JWT")));
    }
}

// .vscode/settings.json
{
    "chat.agent.enabled": true,
    "github.copilot.chat.agent.runInTerminal": true,
    "github.copilot.chat.agent.fileEditing": true
}

// .vscode/settings.json — Copilot Hooks
{
    "github.copilot.chat.agent.hooks": {
        "postSave": {
            "command": "mvn compile -q",
            "description": "Agent 儲存檔案後自動編譯驗證"
        },
        "postCreate": {
            "command": "mvn checkstyle:check -q",
            "description": "Agent 建立新檔案後自動檢查 Code Style"
        }
    }
}

# .github/copilot/config.yml
agent:
  validation:
    build_command: "mvn clean compile -q"
    test_command: "mvn test -q"
    lint_command: "mvn checkstyle:check -q"
  permissions:
    file_access: "src/**"
    terminal: true

// .vscode/settings.json
{
    "mcp": {
        "servers": {
            "database-analyzer": {
                "command": "npx",
                "args": ["-y", "@mcp/postgres-server"],
                "env": {
                    "DATABASE_URL": "${env:LEGACY_DB_URL}"
                }
            },
            "sonarqube": {
                "command": "npx",
                "args": ["-y", "@mcp/sonarqube-server"],
                "env": {
                    "SONAR_URL": "http://sonarqube:9000",
                    "SONAR_TOKEN": "${env:SONAR_TOKEN}"
                }
            },
            "filesystem": {
                "command": "npx",
                "args": ["-y", "@mcp/filesystem-server", 
                         "--path", "./legacy-cms"]
            }
        }
    }
}

# Agent Mode + MCP Prompt

使用 database-analyzer MCP 連接舊系統資料庫，完成以下任務：

1. 列出所有 Table 與 View
2. 產出完整 ERD（Mermaid 格式）
3. 識別孤立表（無外鍵關聯）
4. 識別缺少索引的查詢欄位
5. 產出 Flyway 遷移腳本（DB2 → PostgreSQL）

同時使用 sonarqube MCP 掃描 Legacy 專案，產出安全風險報告。

# .github/workflows/copilot-review.yml
name: Copilot Code Review

on:
  pull_request:
    types: [opened, synchronize]
    paths:
      - 'src/**'

jobs:
  copilot-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Request Copilot Review
        uses: github/copilot-code-review@v1
        with:
          scope: "security,performance,best-practices"

# .github/copilot-review-instructions.md

## 逆向工程 Code Review 重點

請在審查遷移後的程式碼時，特別注意：
1. 所有商業規則是否完整保留（對照 BR-xxx 清冊）
2. SQL Injection 等安全漏洞是否已修正
3. 是否使用 JPA 參數化查詢（非字串拼接）
4. 是否包含適當的 Input Validation
5. 日誌是否避免記錄敏感資料
6. 例外處理是否適當（不吞掉例外）
7. 是否有對應的單元測試