PROMPT 1

Saya akan upload fail ZIP yang mengandungi source code project. Tolong analisa codebase ini untuk bantu saya faham sistem secara menyeluruh.

Cara analisa:
1. Mula dengan kenal pasti struktur folder utama dan terangkan peranan setiap folder penting.
2. Kenal pasti tech stack: bahasa, framework, library utama, package manager, database, cache, queue, API integration, dan tools build/deploy/test.
3. Cari entry point utama project seperti main app file, routes, controllers, services, workers, schedulers, dan config penting.
4. Terangkan architecture sistem pada high level: bagaimana komponen berhubung antara satu sama lain.
5. Jelaskan flow utama sistem, contohnya: - request masuk dari mana - diproses oleh file/module mana - pergi ke service/database mana - response dibina bagaimana
6. Pecahkan modul utama satu per satu dan terangkan: - tanggungjawab modul - file penting - class/function penting - dependency antara modul
7. Kenal pasti: - config/env yang penting - external service yang digunakan - authentication/authorization flow - database model/schema/migration jika ada - API endpoints penting jika ada
8. Senaraikan isu yang nampak seperti: - code smell - duplicated logic - dead code - bug berpotensi - security risk - technical debt
9. Akhir sekali, buat ringkasan onboarding untuk developer baru:
- sistem ini buat apa
- modul mana patut dibaca dulu
- file paling penting
- flow paling kritikal
- risiko atau bahagian yang mengelirukan

Peraturan jawapan:
- Rujuk file path sebenar bila buat penerangan.
- Kalau tak pasti, nyatakan jelas bahawa itu andaian.
- Jangan explain terlalu umum; kaitkan penerangan dengan code dalam project.
- Kalau codebase besar, mula dengan overview dahulu, kemudian sambung analisa ikut modul paling penting.
- Gunakan format:
1. Ringkasan keseluruhan
2. Struktur folder
3. Tech stack
4. Architecture
5. Flow utama
6. Modul penting
7. Cara project dijalankan
8. Risiko/isu
9. Cadangan next step Untuk setiap penerangan penting, sertakan nama fail, function, class, atau route yang berkaitan supaya saya boleh cross-check terus dalam code.


PROMPT 2

Aku nak rebuild semula module Pemohon dan Backend dalam project CodeIgniter 4 aku.
Aku nak buat semula dengan pendekatan baru yang lebih clean, scalable, dan maintainable.
Kekalkan business rule penting, tapi kalau database, flow, controller, service, atau UI perlu ubah, terus cadangkan yang lebih baik.
Pecahkan module jika perlu.

Aku nak kau bantu macam ni:
1. semak kelemahan module lama
2. cadangkan structure baru
3. susun flow baru
4. kalau perlu redesign table
5. bagi implementation plan
6. teruskan dengan full code

Target versi baru:
- enterprise-ready
- modular
- senang debug
- senang tambah feature lepas ni
- tak terlalu berat Jangan terus hasilkan code penuh pada jawapan pertama.

Mula dengan audit, cadangan architecture baru, flow baru, dan pelan implementation dulu.
Jawab dalam BM.
Jangan teori panjang.
Kalau ada assumption, nyatakan ringkas.
Jangan ubah logic penting tanpa sebab.


prompt 3

Anda ialah senior software architect + lead CodeIgniter 4 engineer.

Saya sedang rebuild semula project pengambilan ini, khususnya modul **Pemohon** dan **Backend/Admin**, daripada codebase lama yang messy kepada versi baru yang lebih clean, modular, scalable, maintainable, dan enterprise-ready tetapi masih ringan.

## Konteks projek

Project lama ialah sistem e-pengambilan / kerjaya berasaskan CodeIgniter, dengan dua modul utama:

1. **Pemohon**
2. **Backend/Admin**

Sistem lama ada flow seperti:

* daftar akaun pemohon
* login pemohon
* isi profil pemohon
* hantar permohonan
* pemilihan awal
* pemilihan akhir
* psikometrik
* DASS
* temuduga / tred
* tawaran / kehadiran / sertai
* dashboard dan operasi admin
* import/export data

## Objektif

Saya nak bina semula versi baru dengan ciri berikut:

* CodeIgniter 4
* server-rendered UI (bukan SPA penuh)
* modular monolith
* controller nipis
* service / use case layer jelas
* query layer jelas
* senang debug
* senang tambah feature
* tak terlalu berat
* audit trail lebih baik
* explicit routes
* role/authorization lebih kemas

## Peraturan penting

1. **Jangan ubah business rule penting tanpa sebab yang kuat.**
2. Kalau ada logic lama yang kritikal, cadangkan cara kekalkan logic itu tetapi pindahkan ke architecture yang lebih baik.
3. Kalau nampak table/schema lama buruk, boleh cadangkan redesign — tapi buat secara praktikal, bukan terlalu over-engineered.
4. Kekalkan CI4 sebagai framework utama.
5. Jangan paksa microservices.
6. Jangan hasilkan teori terlalu panjang.
7. Bila tak pasti, nyatakan sebagai assumption ringkas.
8. Semua cadangan mesti practical untuk implementation sebenar.

## Masalah utama sistem lama yang perlu diambil kira

Sistem lama ada kelemahan seperti:

* controller terlalu besar
* business rule bertabur dalam controller dan BaseController
* raw SQL bercampur dalam controller/view
* status flow banyak bergantung pada string
* authorization manual dan kasar
* backend bercampur CRUD + workflow + reporting
* struktur table tidak normalize dengan baik
* flow pusat awal/akhir/sertai dipecah kepada table berasingan
* tred/quota susah discale
* code lama banyak technical debt
* flow auth / reset / admin ada mismatch schema lama vs baru

## Business rule penting yang mesti dipelihara

Anggap rule ini perlu dipindahkan ke implementation baru:

* semakan intake / borang aktif
* semakan borang khas
* kira kelengkapan profil pemohon
* derive maklumat tertentu dari MyKad/IC jika perlu
* journey status pemohon mengikut stage
* flow stage:

  * permohonan
  * pemilihan awal
  * pemilihan akhir
  * temuduga / assignment tred
  * sertai
* flow psikometrik
* flow DASS
* pengesahan hadir / tawaran ikut stage
* audit perubahan penting oleh admin

## Target architecture

Saya cenderung kepada structure seperti ini:

app/
Modules/
Candidate/
Config/
Controllers/
UseCases/
Queries/
DTO/
Validation/
Views/
Admin/
Config/
Controllers/
UseCases/
Queries/
DTO/
Validation/
Views/
Domain/
Recruitment/
Infrastructure/
Persistence/
Auth/
Audit/

Tapi anda boleh kemaskan kalau perlu, asalkan masih practical untuk CI4.

## Cadangan domain/module yang saya mahu

### Modul Candidate

* Dashboard
* Profile
* Application
* Invitation
* Assessment
* Document

### Modul Admin

* Dashboard
* Intake
* Center
* Application Review
* Early Selection
* Final Selection
* Interview
* Trade
* Staff
* Report

## Jangkaan redesign database

Saya terbuka untuk redesign table. Saya jangka sekurang-kurangnya anda akan semak sama ada patut:

* tukar `mohon` kepada `applications`
* gabungkan stage result kepada struktur yang lebih konsisten
* gabungkan `pusat_awal`, `pusat_akhir`, `pusat_sertai`
* normalize tred/quota/assignment
* kemaskan table staff + role
* kekalkan `users` buat sementara jika itu lebih practical

## Tugas anda

Saya mahu anda bantu saya secara berperingkat.

### FASA 1 — Blueprint implementation

Mula dengan hasilkan:

1. senarai assumption ringkas
2. bounded context / modul breakdown
3. architecture folder yang disyorkan
4. route map baru untuk Candidate dan Admin
5. controller list
6. service / use case list
7. query service list
8. validation/request DTO list
9. cadangan enum / constant status
10. database redesign proposal
11. migration strategy dari struktur lama ke baru
12. authorization/role strategy
13. audit logging strategy
14. implementation roadmap mengikut fasa
15. risiko migration / compatibility
16. senarai komponen mana patut dibina dulu

### FASA 2 — Detail design

Selepas blueprint dipersetujui, hasilkan:

1. table-by-table design
2. entity responsibility
3. service contract / method signature
4. request-response flow setiap modul
5. sequence flow untuk:

   * submit application
   * early selection
   * final selection
   * interview/trade assignment
   * confirm attendance
   * psychometric
   * DASS

### FASA 3 — Code generation

Selepas design siap, hasilkan code secara berperingkat:

1. migrations
2. enums/constants
3. entities/models
4. repositories/query classes
5. services/use cases
6. controllers
7. filters/auth
8. routes
9. views
10. sample tests

## Cara jawab

Bila anda jawab:

* jawab dalam **Bahasa Melayu**
* jangan teori terlalu panjang
* fokus pada tindakan yang practical
* guna heading yang jelas
* bila sebut sesuatu komponen, beri nama class/file yang dicadangkan
* jangan terus generate semua code penuh jika saya belum minta
* jika ada part yang sepatutnya legacy-compatible, tandakan jelas
* kalau anda cadangkan ubah business rule, terangkan sebab ringkas

## Format output yang saya mahu sekarang

Untuk respons ini, hasilkan **Blueprint Implementation** dengan format berikut:

1. Assumption
2. Modul & bounded context
3. Struktur folder baru
4. Route map baru
5. Controller & tanggungjawab
6. Service / UseCase list
7. Query layer list
8. Validation / DTO list
9. Enum / status design
10. Cadangan redesign database
11. Strategi migration data lama -> baru
12. Auth / role / permission design
13. Audit log design
14. Fasa implementation
15. Risiko utama
16. Build order paling sesuai

## Guardrail

* Jangan terus bagi code penuh.
* Jangan bagi pseudo-architecture yang terlalu generic.
* Jangan cadang teknologi yang lari jauh dari CI4 tanpa sebab.
* Jangan pecahkan ke microservice.
* Jangan ubah logic penting sesuka hati.
* Semua cadangan mesti align dengan sistem pengambilan sebenar.

Sekarang hasilkan **Blueprint Implementation** penuh berdasarkan arahan di atas.