> ## Documentation Index
> Fetch the complete documentation index at: https://cli.fuxicode.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Bagaimana Fuxi mengingat proyek Anda
> Berikan Fuxi instruksi persisten dengan file FUXI.md, dan biarkan Fuxi mengumpulkan pembelajaran secara otomatis dengan auto memory.
Setiap sesi Fuxi Code dimulai dengan context window yang segar. Dua mekanisme membawa pengetahuan lintas sesi:
* **File FUXI.md**: instruksi yang Anda tulis untuk memberikan Fuxi konteks persisten
* **Auto memory**: catatan yang Fuxi tulis sendiri berdasarkan koreksi dan preferensi Anda
Halaman ini mencakup cara untuk:
* [Menulis dan mengorganisir file FUXI.md](#fuxi-md-files)
* [Membatasi aturan ke tipe file tertentu](#organize-rules-with-fuxi/rules/) dengan `.fuxi/rules/`
* [Mengonfigurasi auto memory](#auto-memory) agar Fuxi membuat catatan secara otomatis
* [Troubleshoot](#troubleshoot-memory-issues) ketika instruksi tidak diikuti
FUXI.md vs auto memory
Fuxi Code memiliki dua sistem memori yang saling melengkapi. Keduanya dimuat di awal setiap percakapan. Fuxi memperlakukan mereka sebagai konteks, bukan konfigurasi yang diberlakukan. Untuk memblokir suatu tindakan terlepas dari apa yang Fuxi putuskan, gunakan [hook PreToolUse](/id/hooks-guide) sebagai gantinya. Semakin spesifik dan ringkas instruksi Anda, semakin konsisten Fuxi mengikutinya.
| | File FUXI.md | Auto memory |
| :------------------------ | :------------------------------------------------ | :---------------------------------------------------------------- |
| **Siapa yang menulisnya** | Anda | Fuxi |
| **Apa yang dikandungnya** | Instruksi dan aturan | Pembelajaran dan pola |
| **Cakupan** | Proyek, pengguna, atau organisasi | Per repositori, dibagikan di seluruh worktrees |
| **Dimuat ke dalam** | Setiap sesi | Setiap sesi (200 baris pertama atau 25KB) |
| **Gunakan untuk** | Standar pengkodean, alur kerja, arsitektur proyek | Perintah build, wawasan debugging, preferensi yang Fuxi temukan |
Gunakan file FUXI.md ketika Anda ingin memandu perilaku Fuxi. Auto memory memungkinkan Fuxi belajar dari koreksi Anda tanpa usaha manual.
Subagents juga dapat mempertahankan auto memory mereka sendiri. Lihat [konfigurasi subagent](/id/sub-agents#enable-persistent-memory) untuk detail.
File FUXI.md
File FUXI.md adalah file markdown yang memberikan Fuxi instruksi persisten untuk proyek, alur kerja pribadi Anda, atau seluruh organisasi Anda. Anda menulis file ini dalam teks biasa; Fuxi membacanya di awal setiap sesi.
Kapan harus menambahkan ke FUXI.md
Perlakukan FUXI.md sebagai tempat Anda menulis apa yang sebaliknya akan Anda jelaskan kembali. Tambahkan ke dalamnya ketika:
* Fuxi membuat kesalahan yang sama untuk kedua kalinya
* Tinjauan kode menangkap sesuatu yang seharusnya Fuxi ketahui tentang basis kode ini
* Anda mengetik koreksi atau klarifikasi yang sama ke dalam chat yang Anda ketik di sesi terakhir
* Anggota tim baru akan membutuhkan konteks yang sama untuk produktif
Pertahankan fakta yang seharusnya Fuxi pegang di setiap sesi: perintah build, konvensi, tata letak proyek, aturan "selalu lakukan X". Jika entri adalah prosedur multi-langkah atau hanya penting untuk satu bagian dari basis kode, pindahkan ke [skill](/id/skills) atau [aturan bersyarat jalur](#organize-rules-with-fuxi/rules/) sebagai gantinya. [Gambaran umum ekstensi](/id/features-overview#build-your-setup-over-time) mencakup kapan menggunakan setiap mekanisme.
Pilih di mana menempatkan file FUXI.md
File FUXI.md dapat berada di beberapa lokasi, masing-masing dengan cakupan yang berbeda. Tabel di bawah mencantumkan mereka dalam urutan pemuatan, dari cakupan terluas hingga paling spesifik, jadi instruksi proyek muncul dalam konteks setelah instruksi pengguna.
| Cakupan | Lokasi | Tujuan | Contoh kasus penggunaan | Dibagikan dengan |
| ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------------------ | ---------------------------------- |
| **Kebijakan terkelola** | • macOS: `/Library/Application Support/FuxiCode/FUXI.md`
• Linux dan WSL: `/etc/fuxi-code/FUXI.md`
• Windows: `C:\Program Files\FuxiCode\FUXI.md` | Instruksi di seluruh organisasi yang dikelola oleh IT/DevOps | Standar pengkodean perusahaan, kebijakan keamanan, persyaratan kepatuhan | Semua pengguna dalam organisasi |
| **Instruksi pengguna** | `~/.fuxi/FUXI.md` | Preferensi pribadi untuk semua proyek | Preferensi gaya kode, pintasan alat pribadi | Hanya Anda (semua proyek) |
| **Instruksi proyek** | `./FUXI.md` atau `./.fuxi/FUXI.md` | Instruksi bersama tim untuk proyek | Arsitektur proyek, standar pengkodean, alur kerja umum | Anggota tim melalui kontrol sumber |
| **Instruksi lokal** | `./FUXI.local.md` | Preferensi pribadi khusus proyek; tambahkan ke `.gitignore` | URL sandbox Anda, data test pilihan | Hanya Anda (proyek saat ini) |
File FUXI.md dan FUXI.local.md dalam hierarki direktori di atas direktori kerja dimuat sepenuhnya saat peluncuran. File di subdirektori dimuat sesuai permintaan ketika Fuxi membaca file di direktori tersebut. Lihat [Bagaimana file FUXI.md dimuat](#how-fuxi-md-files-load) untuk urutan resolusi lengkap.
Untuk proyek besar, Anda dapat memecah instruksi menjadi file khusus topik menggunakan [aturan proyek](#organize-rules-with-fuxi/rules/). Aturan memungkinkan Anda membatasi instruksi ke tipe file atau subdirektori tertentu.
Siapkan FUXI.md proyek
FUXI.md proyek dapat disimpan di `./FUXI.md` atau `./.fuxi/FUXI.md`. Buat file ini dan tambahkan instruksi yang berlaku untuk siapa pun yang bekerja pada proyek: perintah build dan test, standar pengkodean, keputusan arsitektur, konvensi penamaan, dan alur kerja umum. Instruksi ini dibagikan dengan tim Anda melalui kontrol versi, jadi fokus pada standar tingkat proyek daripada preferensi pribadi.
Jalankan `/init` untuk menghasilkan FUXI.md awal secara otomatis. Fuxi menganalisis basis kode Anda dan membuat file dengan perintah build, instruksi test, dan konvensi proyek yang ditemukannya. Jika FUXI.md sudah ada, `/init` menyarankan perbaikan daripada menimpanya. Perbaiki dari sana dengan instruksi yang Fuxi tidak akan temukan sendiri.
Atur `FUXI_CODE_NEW_INIT=1` untuk mengaktifkan alur multi-fase interaktif. `/init` menanyakan artefak mana yang akan diatur: file FUXI.md, skills, dan hooks. Kemudian mengeksplorasi basis kode Anda dengan subagent, mengisi celah melalui pertanyaan lanjutan, dan menyajikan proposal yang dapat ditinjau sebelum menulis file apa pun.
Tulis instruksi yang efektif
File FUXI.md dimuat ke dalam context window di awal setiap sesi, mengonsumsi token bersama percakapan Anda. [Visualisasi context window](/id/context-window) menunjukkan di mana FUXI.md dimuat relatif terhadap sisa startup context. Karena mereka adalah konteks daripada konfigurasi yang diberlakukan, cara Anda menulis instruksi mempengaruhi seberapa andal Fuxi mengikutinya. Instruksi yang spesifik, ringkas, dan terstruktur dengan baik bekerja paling baik.
**Ukuran**: targetkan di bawah 200 baris per file FUXI.md. File yang lebih panjang mengonsumsi lebih banyak konteks dan mengurangi kepatuhan. Jika instruksi Anda berkembang besar, gunakan [aturan bersyarat jalur](#path-specific-rules) sehingga instruksi hanya dimuat ketika Fuxi bekerja dengan file yang cocok, menghemat ruang konteks. Anda juga dapat membagi konten menjadi [impor](#import-additional-files) untuk organisasi, meskipun file yang diimpor masih dimuat dan memasuki context window saat peluncuran.
**Struktur**: gunakan header markdown dan bullet untuk mengelompokkan instruksi terkait. Fuxi memindai struktur dengan cara yang sama seperti pembaca: bagian yang terorganisir lebih mudah diikuti daripada paragraf padat.
**Spesifisitas**: tulis instruksi yang cukup konkret untuk diverifikasi. Misalnya:
* "Gunakan indentasi 2 spasi" daripada "Format kode dengan baik"
* "Jalankan `npm test` sebelum commit" daripada "Uji perubahan Anda"
* "Handler API berada di `src/api/handlers/`" daripada "Jaga file tetap terorganisir"
**Konsistensi**: jika dua aturan saling bertentangan, Fuxi mungkin memilih satu secara sembarangan. Tinjau file FUXI.md Anda, file FUXI.md bersarang di subdirektori, dan file [`.fuxi/rules/`](#organize-rules-with-fuxi/rules/) secara berkala untuk menghapus instruksi yang ketinggalan zaman atau bertentangan. Dalam monorepo, gunakan [`fuxiMdExcludes`](#exclude-specific-fuxi-md-files) untuk melewati file FUXI.md dari tim lain yang tidak relevan dengan pekerjaan Anda.
Impor file tambahan
File FUXI.md dapat mengimpor file tambahan menggunakan sintaks `@path/to/import`. File yang diimpor diperluas dan dimuat ke dalam konteks saat peluncuran bersama FUXI.md yang mereferensikannya.
Jalur relatif dan absolut diizinkan. Jalur relatif diselesaikan relatif terhadap file yang berisi impor, bukan direktori kerja. File yang diimpor dapat secara rekursif mengimpor file lain, dengan kedalaman maksimal empat hop.
Penguraian impor melewati rentang kode Markdown dan blok kode yang dibatasi. Untuk menyebutkan jalur di FUXI.md Anda tanpa mengimpornya, bungkus dalam backtick: menulis `` `@README` `` membuat teks tetap literal, sementara `@README` di luar backtick mengimpor file.
Untuk menarik README, package.json, dan panduan alur kerja, referensikan mereka dengan sintaks `@` di mana saja di FUXI.md Anda:
```text theme={null}
Lihat @README untuk gambaran umum proyek dan @package.json untuk perintah npm yang tersedia untuk proyek ini.
# Instruksi Tambahan
- alur kerja git @docs/git-instructions.md
```
Untuk preferensi pribadi per-proyek yang tidak ingin Anda periksa ke dalam kontrol versi, buat `FUXI.local.md` di root proyek. Itu dimuat bersama `FUXI.md` dan diperlakukan dengan cara yang sama. Tambahkan `FUXI.local.md` ke `.gitignore` Anda sehingga tidak dikomit; menjalankan `/init` dan memilih opsi pribadi melakukan ini untuk Anda.
Jika Anda bekerja di seluruh beberapa git worktrees dari repositori yang sama, `FUXI.local.md` yang diabaikan git hanya ada di worktree tempat Anda membuatnya. Untuk berbagi instruksi pribadi di seluruh worktrees, impor file dari direktori home Anda sebagai gantinya:
```text theme={null}
# Preferensi Individu
- @~/.fuxi/my-project-instructions.md
```
Pertama kali Fuxi Code menemukan impor eksternal dalam proyek, itu menampilkan dialog persetujuan yang mencantumkan file. Jika Anda menolak, impor tetap dinonaktifkan dan dialog tidak muncul lagi.
Untuk pendekatan yang lebih terstruktur untuk mengorganisir instruksi, lihat [`.fuxi/rules/`](#organize-rules-with-fuxi/rules/).
AGENTS.md
Fuxi Code membaca `FUXI.md`, bukan `AGENTS.md`. Jika repositori Anda sudah menggunakan `AGENTS.md` untuk agen pengkodean lain, buat `FUXI.md` yang mengimpornya sehingga kedua alat membaca instruksi yang sama tanpa menduplikasinya. Anda juga dapat menambahkan instruksi khusus Fuxi di bawah impor. Fuxi memuat file yang diimpor saat awal sesi, kemudian menambahkan sisanya:
```markdown FUXI.md theme={null}
@AGENTS.md
## Fuxi Code
Gunakan plan mode untuk perubahan di bawah `src/billing/`.
```
Symlink juga berfungsi jika Anda tidak perlu menambahkan konten khusus Fuxi:
```bash theme={null}
ln -s AGENTS.md FUXI.md
```
Di Windows, membuat symlink memerlukan hak istimewa Administrator atau Developer Mode, jadi gunakan impor `@AGENTS.md` sebagai gantinya.
Menjalankan [`/init`](/id/commands) di repo yang sudah memiliki `AGENTS.md` membacanya dan menggabungkan bagian yang relevan ke dalam `FUXI.md` yang dihasilkan. Itu juga membaca konfigurasi alat lain seperti `.cursorrules`, `.devin/rules/`, dan `.windsurfrules`.
Bagaimana file FUXI.md dimuat
Fuxi Code membaca file FUXI.md dengan berjalan naik pohon direktori dari direktori kerja saat ini, memeriksa setiap direktori di sepanjang jalan untuk file `FUXI.md` dan `FUXI.local.md`. Ini berarti jika Anda menjalankan Fuxi Code di `foo/bar/`, itu memuat instruksi dari `foo/bar/FUXI.md`, `foo/FUXI.md`, dan file `FUXI.local.md` apa pun di sebelahnya.
Semua file yang ditemukan digabungkan ke dalam konteks daripada menimpa satu sama lain. Dalam setiap direktori, konten diurutkan dari root sistem file ke bawah ke direktori kerja Anda. Untuk contoh `foo/bar/`, `foo/FUXI.md` muncul dalam konteks sebelum `foo/bar/FUXI.md`, jadi instruksi yang lebih dekat dengan tempat Anda meluncurkan Fuxi dibaca terakhir. Dalam setiap direktori, `FUXI.local.md` ditambahkan setelah `FUXI.md`, jadi catatan pribadi Anda adalah hal terakhir yang Fuxi baca di tingkat itu.
Fuxi juga menemukan file `FUXI.md` dan `FUXI.local.md` di subdirektori di bawah direktori kerja saat ini. Alih-alih memuatnya saat peluncuran, mereka disertakan ketika Fuxi membaca file di subdirektori tersebut.
Jika Anda bekerja di monorepo besar di mana file FUXI.md tim lain diambil, gunakan [`fuxiMdExcludes`](#exclude-specific-fuxi-md-files) untuk melewatinya. Untuk tata letak lengkap file FUXI.md root dan per-direktori serta aturan, lihat [Monorepo dan repo besar](/id/large-codebases).
Komentar HTML tingkat blok (``) dalam file FUXI.md dihapus sebelum konten disuntikkan ke dalam konteks Fuxi. Gunakan mereka untuk meninggalkan catatan bagi pengelola manusia tanpa menghabiskan token konteks pada mereka. Komentar di dalam blok kode dipertahankan. Ketika Anda membuka file FUXI.md secara langsung dengan alat Read, komentar tetap terlihat.
Muat dari direktori tambahan
Flag `--add-dir` memberikan Fuxi akses ke direktori tambahan di luar direktori kerja utama Anda. Secara default, file FUXI.md dari direktori ini tidak dimuat.
Untuk juga memuat file memori dari direktori tambahan, atur variabel lingkungan `FUXI_CODE_ADDITIONAL_DIRECTORIES_FUXI_MD`:
```bash theme={null}
FUXI_CODE_ADDITIONAL_DIRECTORIES_FUXI_MD=1 fuxi --add-dir ../shared-config
```
Ini memuat `FUXI.md`, `.fuxi/FUXI.md`, `.fuxi/rules/*.md`, dan `FUXI.local.md` dari direktori tambahan. `FUXI.local.md` dilewati jika Anda mengecualikan `local` dari [`--setting-sources`](/id/cli-reference).
Organisir aturan dengan `.fuxi/rules/`
Untuk proyek yang lebih besar, Anda dapat mengorganisir instruksi menjadi beberapa file menggunakan direktori `.fuxi/rules/`. Ini membuat instruksi modular dan lebih mudah bagi tim untuk dipertahankan. Aturan juga dapat [dibatasi ke jalur file tertentu](#path-specific-rules), sehingga mereka hanya dimuat ke dalam konteks ketika Fuxi bekerja dengan file yang cocok, mengurangi kebisingan dan menghemat ruang konteks.
Aturan dimuat ke dalam konteks setiap sesi atau ketika file yang cocok dibuka. Untuk instruksi khusus tugas yang tidak perlu berada dalam konteks sepanjang waktu, gunakan [skills](/id/skills) sebagai gantinya, yang hanya dimuat ketika Anda menginvokasinya atau ketika Fuxi menentukan mereka relevan dengan prompt Anda.
Siapkan aturan
Tempatkan file markdown di direktori `.fuxi/rules/` proyek Anda. Setiap file harus mencakup satu topik, dengan nama file deskriptif seperti `testing.md` atau `api-design.md`. Semua file `.md` ditemukan secara rekursif, jadi Anda dapat mengorganisir aturan ke dalam subdirektori seperti `frontend/` atau `backend/`:
```text theme={null}
your-project/
├── .fuxi/
│ ├── FUXI.md # Instruksi proyek utama
│ └── rules/
│ ├── code-style.md # Pedoman gaya kode
│ ├── testing.md # Konvensi pengujian
│ └── security.md # Persyaratan keamanan
```
Aturan tanpa [frontmatter `paths`](#path-specific-rules) dimuat saat peluncuran dengan prioritas yang sama seperti `.fuxi/FUXI.md`.
Aturan khusus jalur
Aturan dapat dibatasi ke file tertentu menggunakan frontmatter YAML dengan bidang `paths`. Aturan bersyarat ini hanya berlaku ketika Fuxi bekerja dengan file yang cocok dengan pola yang ditentukan.
```markdown theme={null}
---
paths:
- "src/api/**/*.ts"
---
# Aturan Pengembangan API
- Semua endpoint API harus menyertakan validasi input
- Gunakan format respons kesalahan standar
- Sertakan komentar dokumentasi OpenAPI
```
Aturan tanpa bidang `paths` dimuat tanpa syarat dan berlaku untuk semua file. Aturan bersyarat jalur dipicu ketika Fuxi membaca file yang cocok dengan pola, bukan pada setiap penggunaan alat. Sejak v2.1.198, pencocokan juga berfungsi ketika Fuxi mencapai file melalui jalur symlink ke direktori proyek, misalnya dalam checkout yang disymlink.
Gunakan pola glob di bidang `paths` untuk mencocokkan file berdasarkan ekstensi, direktori, atau kombinasi apa pun:
| Pola | Cocok dengan |
| ---------------------- | ------------------------------------------ |
| `**/*.ts` | Semua file TypeScript di direktori apa pun |
| `src/**/*` | Semua file di bawah direktori `src/` |
| `*.md` | File Markdown di root proyek |
| `src/components/*.tsx` | Komponen React di direktori tertentu |
Anda dapat menentukan beberapa pola dan menggunakan ekspansi brace untuk mencocokkan beberapa ekstensi dalam satu pola:
```markdown theme={null}
---
paths:
- "src/**/*.{ts,tsx}"
- "lib/**/*.ts"
- "tests/**/*.test.ts"
---
```
Bagikan aturan lintas proyek dengan symlinks
Direktori `.fuxi/rules/` mendukung symlinks, jadi Anda dapat mempertahankan set aturan bersama dan menautkannya ke beberapa proyek. Symlinks diselesaikan dan dimuat secara normal, dan symlinks melingkar terdeteksi dan ditangani dengan anggun.
Contoh ini menautkan direktori bersama dan file individual:
```bash theme={null}
ln -s ~/shared-fuxi-rules .fuxi/rules/shared
ln -s ~/company-standards/security.md .fuxi/rules/security.md
```
Aturan tingkat pengguna
Aturan pribadi di `~/.fuxi/rules/` berlaku untuk setiap proyek di mesin Anda. Gunakan untuk preferensi yang bukan khusus proyek:
```text theme={null}
~/.fuxi/rules/
├── preferences.md # Preferensi pengkodean pribadi Anda
└── workflows.md # Alur kerja pilihan Anda
```
Aturan tingkat pengguna dimuat sebelum aturan proyek, memberikan aturan proyek prioritas lebih tinggi.
Kelola FUXI.md untuk tim besar
Untuk organisasi yang menerapkan Fuxi Code di seluruh tim, Anda dapat memusatkan instruksi dan mengontrol file FUXI.md mana yang dimuat.
Terapkan FUXI.md di seluruh organisasi
Organisasi dapat menerapkan FUXI.md yang dikelola secara terpusat yang berlaku untuk semua pengguna di mesin. File ini tidak dapat dikecualikan oleh pengaturan individual.
* macOS: `/Library/Application Support/FuxiCode/FUXI.md`
* Linux dan WSL: `/etc/fuxi-code/FUXI.md`
* Windows: `C:\Program Files\FuxiCode\FUXI.md`
Gunakan MDM, Group Policy, Ansible, atau alat serupa untuk mendistribusikan file di seluruh mesin pengembang. Lihat [pengaturan terkelola](/id/permissions#managed-settings) untuk opsi konfigurasi di seluruh organisasi lainnya.
Kunci `fuxiMd` memungkinkan Anda menempatkan konten FUXI.md terkelola langsung di dalam `managed-settings.json` alih-alih menerapkan file terpisah.
**Cakupan**: setiap sesi Fuxi Code di mesin, di setiap repositori. Untuk panduan khusus repositori, komit FUXI.md proyek sebagai gantinya.
**Prioritas**: sama dengan file FUXI.md terkelola. Dimuat sebelum FUXI.md pengguna dan proyek.
**Di mana itu dihormati**: pengaturan terkelola dan kebijakan saja. Menetapkan `fuxiMd` dalam pengaturan pengguna, proyek, atau lokal tidak berpengaruh.
Contoh di bawah menambahkan instruksi perilaku langsung dalam file pengaturan terkelola:
```json theme={null}
{
"fuxiMd": "Always run `make lint` before committing.\nNever push directly to main."
}
```
FUXI.md terkelola dan [pengaturan terkelola](/id/settings#settings-files) melayani tujuan yang berbeda. Gunakan pengaturan untuk penegakan teknis dan FUXI.md untuk panduan perilaku:
| Kekhawatiran | Konfigurasi dalam |
| :---------------------------------------------- | :------------------------------------------------------------ |
| Blokir alat, perintah, atau jalur file tertentu | Pengaturan terkelola: `permissions.deny` |
| Paksakan isolasi sandbox | Pengaturan terkelola: `sandbox.enabled` |
| Variabel lingkungan dan perutean penyedia API | Pengaturan terkelola: `env` |
| Metode autentikasi dan kunci organisasi | Pengaturan terkelola: `forceLoginMethod`, `forceLoginOrgUUID` |
| Panduan gaya kode dan kualitas | FUXI.md terkelola |
| Pengingat penanganan data dan kepatuhan | FUXI.md terkelola |
| Instruksi perilaku untuk Fuxi | FUXI.md terkelola |
Aturan pengaturan diberlakukan oleh klien terlepas dari apa yang Fuxi putuskan untuk dilakukan. Instruksi FUXI.md membentuk perilaku Fuxi tetapi bukan lapisan penegakan keras.
Kecualikan file FUXI.md tertentu
Dalam monorepo besar, file FUXI.md leluhur mungkin berisi instruksi yang tidak relevan dengan pekerjaan Anda. Pengaturan `fuxiMdExcludes` memungkinkan Anda melewati file tertentu berdasarkan jalur atau pola glob.
Contoh ini mengecualikan FUXI.md tingkat atas dan direktori aturan dari folder induk. Tambahkan ke `.fuxi/settings.local.json` agar pengecualian tetap lokal ke mesin Anda:
```json theme={null}
{
"fuxiMdExcludes": [
"**/monorepo/FUXI.md",
"/home/user/monorepo/other-team/.fuxi/rules/**"
]
}
```
Pola dicocokkan dengan jalur file absolut menggunakan sintaks glob. Anda dapat mengonfigurasi `fuxiMdExcludes` di lapisan [pengaturan](/id/settings#settings-files) apa pun: pengguna, proyek, lokal, atau kebijakan terkelola. Array digabungkan di seluruh lapisan.
File FUXI.md kebijakan terkelola tidak dapat dikecualikan. Ini memastikan instruksi di seluruh organisasi selalu berlaku terlepas dari pengaturan individual.
Auto memory
Auto memory memungkinkan Fuxi mengumpulkan pengetahuan lintas sesi tanpa Anda menulis apa pun. Fuxi menyimpan catatan untuk dirinya sendiri saat bekerja: perintah build, wawasan debugging, catatan arsitektur, preferensi gaya kode, dan kebiasaan alur kerja. Fuxi tidak menyimpan sesuatu setiap sesi. Itu memutuskan apa yang layak diingat berdasarkan apakah informasi akan berguna dalam percakapan masa depan.
Aktifkan atau nonaktifkan auto memory
Auto memory aktif secara default. Untuk mengalihkannya, buka `/memory` dalam sesi dan gunakan toggle auto memory, atau atur `autoMemoryEnabled` dalam pengaturan proyek Anda:
```json theme={null}
{
"autoMemoryEnabled": false
}
```
Untuk menonaktifkan auto memory melalui variabel lingkungan, atur `FUXI_CODE_DISABLE_AUTO_MEMORY=1`.
Lokasi penyimpanan
Setiap proyek mendapatkan direktori memori sendiri di `~/.fuxi/projects//memory/`. Jalur `` berasal dari repositori git, jadi semua worktrees dan subdirektori dalam repo yang sama berbagi satu direktori auto memory. Di luar repo git, root proyek digunakan sebagai gantinya.
Untuk menyimpan auto memory di lokasi berbeda, atur `autoMemoryDirectory` dalam `settings.json` Anda. Itu dibaca dari [cakupan pengaturan](/id/settings#settings-precedence) apa pun: pengguna, proyek, lokal, kebijakan, atau `--settings`.
```json theme={null}
{
"autoMemoryDirectory": "~/my-custom-memory-dir"
}
```
Nilai harus berupa jalur absolut atau dimulai dengan `~/`. Ketika diatur dalam `.fuxi/settings.json` atau `.fuxi/settings.local.json` proyek, nilai dihormati hanya setelah Anda menerima dialog kepercayaan ruang kerja untuk folder itu, gerbang yang sama yang mengatur hooks.
Direktori berisi titik masuk `MEMORY.md` dan file topik opsional:
```text theme={null}
~/.fuxi/projects//memory/
├── MEMORY.md # Indeks ringkas, dimuat ke dalam setiap sesi
├── debugging.md # Catatan terperinci tentang pola debugging
├── api-conventions.md # Keputusan desain API
└── ... # File topik lain yang Fuxi buat
```
`MEMORY.md` bertindak sebagai indeks direktori memori. Fuxi membaca dan menulis file di direktori ini sepanjang sesi Anda, menggunakan `MEMORY.md` untuk melacak apa yang disimpan di mana.
Auto memory adalah mesin-lokal. Semua worktrees dan subdirektori dalam repositori git yang sama berbagi satu direktori auto memory. File tidak dibagikan di seluruh mesin atau lingkungan cloud.
Bagaimana cara kerjanya
200 baris pertama `MEMORY.md`, atau 25KB pertama, mana pun yang lebih dulu, dimuat di awal setiap percakapan. Konten di luar batas itu tidak dimuat saat awal sesi. Fuxi membuat `MEMORY.md` ringkas dengan memindahkan catatan terperinci ke file topik terpisah.
Batas ini hanya berlaku untuk `MEMORY.md`. File FUXI.md dimuat sepenuhnya terlepas dari panjangnya, meskipun file yang lebih pendek menghasilkan kepatuhan yang lebih baik.
File topik seperti `debugging.md` atau `patterns.md` tidak dimuat saat startup. Fuxi membacanya sesuai permintaan menggunakan alat file standarnya ketika membutuhkan informasi.
Fuxi membaca dan menulis file memori selama sesi Anda. Ketika Anda melihat "Writing memory" atau "Recalled memory" di antarmuka Fuxi Code, Fuxi secara aktif memperbarui atau membaca dari `~/.fuxi/projects//memory/`.
Audit dan edit memori Anda
File auto memory adalah markdown biasa yang dapat Anda edit atau hapus kapan saja. Jalankan [`/memory`](#view-and-edit-with-%2Fmemory) untuk menelusuri dan membuka file memori dari dalam sesi.
Lihat dan edit dengan `/memory`
Perintah `/memory` mencantumkan semua file FUXI.md, FUXI.local.md, dan rules yang dimuat dalam sesi saat ini, memungkinkan Anda mengalihkan auto memory aktif atau mati, dan menyediakan tautan untuk membuka folder auto memory. Pilih file apa pun untuk membukanya di editor Anda.
Ketika Anda meminta Fuxi untuk mengingat sesuatu, seperti "selalu gunakan pnpm, bukan npm" atau "ingat bahwa tes API memerlukan instans Redis lokal," Fuxi menyimpannya ke auto memory. Untuk menambahkan instruksi ke FUXI.md sebagai gantinya, minta Fuxi secara langsung, seperti "tambahkan ini ke FUXI.md," atau edit file sendiri melalui `/memory`.
Troubleshoot memory issues
Ini adalah masalah paling umum dengan FUXI.md dan auto memory, bersama dengan langkah-langkah untuk men-debug mereka.
Fuxi isn't following my FUXI.md
Konten FUXI.md disampaikan sebagai pesan pengguna setelah prompt sistem, bukan sebagai bagian dari prompt sistem itu sendiri. Fuxi membacanya dan mencoba mengikutinya, tetapi tidak ada jaminan kepatuhan ketat, terutama untuk instruksi yang samar atau bertentangan.
Untuk men-debug:
* Jalankan `/memory` untuk memverifikasi file FUXI.md dan FUXI.local.md Anda dimuat. Jika file tidak terdaftar, Fuxi tidak dapat melihatnya.
* Periksa bahwa FUXI.md yang relevan berada di lokasi yang dimuat untuk sesi Anda (lihat [Choose where to put FUXI.md files](#choose-where-to-put-fuxi-md-files)).
* Buat instruksi lebih spesifik. "Gunakan indentasi 2 spasi" bekerja lebih baik daripada "format kode dengan baik."
* Cari instruksi yang bertentangan di seluruh file FUXI.md. Jika dua file memberikan panduan berbeda untuk perilaku yang sama, Fuxi mungkin memilih satu secara sembarangan.
Jika instruksi adalah sesuatu yang harus berjalan pada titik tertentu, seperti sebelum setiap commit atau setelah setiap pengeditan file, tulislah sebagai [hook](/id/hooks-guide) sebagai gantinya. Hooks dieksekusi sebagai perintah shell pada peristiwa siklus hidup tetap dan berlaku terlepas dari apa yang Fuxi putuskan untuk lakukan.
Untuk instruksi yang Anda inginkan di tingkat prompt sistem, gunakan [`--append-system-prompt`](/id/cli-reference#system-prompt-flags). Ini harus dilewatkan setiap invokasi, jadi lebih cocok untuk skrip dan otomasi daripada penggunaan interaktif.
Gunakan [hook `InstructionsLoaded`](/id/hooks#instructionsloaded) untuk mencatat dengan tepat file instruksi mana yang dimuat, kapan mereka dimuat, dan mengapa. Ini berguna untuk men-debug aturan khusus jalur atau file yang dimuat malas di subdirektori.
I don't know what auto memory saved
Jalankan `/memory` dan pilih folder auto memory untuk menelusuri apa yang telah disimpan Fuxi. Semuanya adalah markdown biasa yang dapat Anda baca, edit, atau hapus.
My FUXI.md is too large
File di atas 200 baris mengonsumsi lebih banyak konteks dan dapat mengurangi kepatuhan. Gunakan [path-scoped rules](#path-specific-rules) untuk memuat instruksi hanya ketika Fuxi bekerja dengan file yang cocok, atau pangkas konten yang tidak diperlukan dalam setiap sesi. Memisahkan ke dalam [impor `@path`](#import-additional-files) membantu organisasi tetapi tidak mengurangi konteks, karena file yang diimpor dimuat saat peluncuran.
Instructions seem lost after `/compact`
FUXI.md root proyek bertahan dari pemadatan: setelah `/compact`, Fuxi membaca ulang dari disk dan menyuntikkannya kembali ke dalam sesi. File FUXI.md bersarang di subdirektori tidak disuntikkan kembali secara otomatis; mereka dimuat ulang saat berikutnya Fuxi membaca file di subdirektori tersebut.
Jika instruksi hilang setelah pemadatan, itu diberikan hanya dalam percakapan atau berada di FUXI.md bersarang yang belum dimuat ulang. Tambahkan instruksi percakapan ke FUXI.md untuk membuatnya bertahan. Lihat [What survives compaction](/id/context-window#what-survives-compaction) untuk rincian lengkap.
Lihat [Write effective instructions](#write-effective-instructions) untuk panduan tentang ukuran, struktur, dan spesifisitas.
* [Debug konfigurasi Anda](/id/debug-your-config): diagnosis mengapa FUXI.md atau pengaturan tidak berlaku
* [Skills](/id/skills): paket alur kerja yang dapat diulang yang dimuat sesuai permintaan
* [Settings](/id/settings): konfigurasi perilaku Fuxi Code dengan file pengaturan
* [Memori subagent](/id/sub-agents#enable-persistent-memory): biarkan subagents mempertahankan auto memory mereka sendiri