+
+**🌐 Dil / Language / 语言 / 語言**
+
+[**English**](../../README.md) | [简体中文](../../README.zh-CN.md) | [繁體中文](../zh-TW/README.md) | [日本語](../ja-JP/README.md) | [한국어](../ko-KR/README.md) | [**Türkçe**](README.md)
+
+
+
+---
+
+**AI agent harness'ları için performans optimizasyon sistemi. Anthropic hackathon kazananından.**
+
+Sadece konfigürasyon dosyaları değil. Tam bir sistem: skill'ler, instinct'ler, memory optimizasyonu, sürekli öğrenme, güvenlik taraması ve araştırma odaklı geliştirme. 10+ ay boyunca gerçek ürünler inşa ederken yoğun günlük kullanımla evrimleşmiş production-ready agent'lar, hook'lar, command'lar, rule'lar ve MCP konfigürasyonları.
+
+**Claude Code**, **Codex**, **Cowork** ve diğer AI agent harness'larında çalışır.
+
+---
+
+## Rehberler
+
+Bu repository yalnızca ham kodu içerir. Rehberler her şeyi açıklıyor.
+
+
+
+
+
+ |
+
+
+
+
+ |
+
+
+
+
+ |
+
| Kısa Rehber Kurulum, temeller, felsefe. İlk önce bunu okuyun. |
+Uzun Rehber Token optimizasyonu, memory kalıcılığı, eval'ler, paralelleştirme. |
+Güvenlik Rehberi Saldırı vektörleri, sandboxing, sanitizasyon, CVE'ler, AgentShield. |
+
+
+
+Hangi agent/command'ların kurulu olduğunu nasıl kontrol ederim?
+ +```bash +/plugin list everything-claude-code@everything-claude-code +``` + +Bu, plugin'den mevcut tüm agent'ları, command'ları ve skill'leri gösterir. +
+
+
+Hook'larım çalışmıyor / "Duplicate hooks file" hatası alıyorum
+ +Bu en yaygın sorundur. `.claude-plugin/plugin.json`'a bir `"hooks"` alanı **EKLEMEYİN**. Claude Code v2.1+ kurulu plugin'lerden `hooks/hooks.json`'ı otomatik olarak yükler. Açıkça belirtmek duplicate algılama hatalarına neden olur. Bkz. [#29](https://github.com/affaan-m/everything-claude-code/issues/29), [#52](https://github.com/affaan-m/everything-claude-code/issues/52), [#103](https://github.com/affaan-m/everything-claude-code/issues/103). +
+
+
+Context window'um küçülüyor / Claude context'ten tükeniyor
+ +Çok fazla MCP server context'inizi tüketiyor. Her MCP tool açıklaması 200k window'unuzdan token tüketir, potansiyel olarak ~70k'ya düşürür. + +**Düzeltme:** Kullanılmayan MCP'leri proje başına devre dışı bırakın: +```json +// Projenizin .claude/settings.json dosyasında +{ + "disabledMcpServers": ["supabase", "railway", "vercel"] +} +``` + +10'dan az MCP etkin ve 80'den az aktif tool tutun. +
+
+
+Sadece bazı component'leri kullanabilir miyim (örn. sadece agent'lar)?
+ +Evet. Seçenek 2'yi (manuel kurulum) kullanın ve yalnızca ihtiyacınız olanı kopyalayın: + +```bash +# Sadece agent'lar +cp everything-claude-code/agents/*.md ~/.claude/agents/ + +# Sadece rule'lar +cp -r everything-claude-code/rules/common/* ~/.claude/rules/ +``` + +Her component tamamen bağımsızdır. +
+
+
+Bu Cursor / OpenCode / Codex / Antigravity ile çalışır mı?
+ +Evet. ECC çapraz platformdur: +- **Cursor**: `.cursor/` içinde önceden çevrilmiş config'ler. [Cursor IDE Desteği](#cursor-ide-desteği) bölümüne bakın. +- **OpenCode**: `.opencode/` içinde tam plugin desteği. [OpenCode Desteği](#-opencode-desteği) bölümüne bakın. +- **Codex**: macOS app ve CLI için birinci sınıf destek. PR [#257](https://github.com/affaan-m/everything-claude-code/pull/257)'ye bakın. +- **Antigravity**: İş akışları, skill'ler ve `.agent/` içinde düzleştirilmiş rule'lar için sıkı entegre kurulum. +- **Claude Code**: Native — bu birincil hedeftir. +
+
+
+---
+
+## 🧪 Testleri Çalıştırma
+
+Plugin kapsamlı bir test suite içerir:
+
+```bash
+# Tüm testleri çalıştır
+node tests/run-all.js
+
+# Bireysel test dosyalarını çalıştır
+node tests/lib/utils.test.js
+node tests/lib/package-manager.test.js
+node tests/hooks/hooks.test.js
+```
+
+---
+
+## 🤝 Katkıda Bulunma
+
+**Katkılar beklenir ve teşvik edilir.**
+
+Bu repo bir topluluk kaynağı olmayı amaçlar. Eğer şunlara sahipseniz:
+- Yararlı agent'lar veya skill'ler
+- Akıllı hook'lar
+- Daha iyi MCP konfigürasyonları
+- İyileştirilmiş rule'lar
+
+Lütfen katkıda bulunun! Rehber için [CONTRIBUTING.md](../../CONTRIBUTING.md)'ye bakın.
+
+### Katkı Fikirleri
+
+- Dile özel skill'ler (Rust, C#, Kotlin, Java) — Go, Python, Perl, Swift ve TypeScript zaten dahil
+- Framework'e özel config'ler (Rails, FastAPI, NestJS) — Django, Spring Boot, Laravel zaten dahil
+- DevOps agent'ları (Kubernetes, Terraform, AWS, Docker)
+- Test stratejileri (farklı framework'ler, görsel regresyon)
+- Domain'e özel bilgi (ML, data engineering, mobile)
+
+---
+
+## 📄 Lisans
+
+MIT - Özgürce kullanın, ihtiyaç duyduğunuz gibi değiştirin, yapabiliyorsanız geri katkıda bulunun.
+
+---
+
+**Bu repo size yardımcı olduysa yıldızlayın. Her iki rehberi de okuyun. Harika bir şey yapın.**
diff --git a/docs/tr/SECURITY.md b/docs/tr/SECURITY.md
new file mode 100644
index 00000000..2eb41da9
--- /dev/null
+++ b/docs/tr/SECURITY.md
@@ -0,0 +1,53 @@
+# Güvenlik Politikası
+
+## Desteklenen Sürümler
+
+| Sürüm | Destekleniyor |
+| ------- | ------------------ |
+| 1.9.x | :white_check_mark: |
+| 1.8.x | :white_check_mark: |
+| < 1.8 | :x: |
+
+## Güvenlik Açığı Bildirimi
+
+ECC'de bir güvenlik açığı keşfederseniz, lütfen sorumlu bir şekilde bildirin.
+
+**Güvenlik açıkları için herkese açık GitHub issue açmayın.**
+
+Bunun yerine, **security@ecc.tools** adresine aşağıdaki bilgilerle e-posta gönderin:
+
+- Güvenlik açığının açıklaması
+- Yeniden oluşturma adımları
+- Etkilenen sürüm(ler)
+- Potansiyel etki değerlendirmesi
+
+Beklentileriniz:
+
+- 48 saat içinde **onay**
+- 7 gün içinde **durum güncellemesi**
+- Kritik sorunlar için 30 gün içinde **düzeltme veya azaltma**
+
+Güvenlik açığı kabul edilirse:
+
+- Sürüm notlarında size teşekkür edeceğiz (anonim kalmayı tercih etmiyorsanız)
+- Sorunu zamanında düzelteceğiz
+- Açıklama zamanlamasını sizinle koordine edeceğiz
+
+Güvenlik açığı reddedilirse, nedenini açıklayacağız ve başka bir yere bildirilmesi gerekip gerekmediği konusunda rehberlik sağlayacağız.
+
+## Kapsam
+
+Bu politika aşağıdakileri kapsar:
+
+- ECC eklentisi ve bu depodaki tüm script'ler
+- Makinenizde çalışan hook script'leri
+- Install/uninstall/repair yaşam döngüsü script'leri
+- ECC ile birlikte gelen MCP konfigürasyonları
+- AgentShield güvenlik tarayıcısı ([github.com/affaan-m/agentshield](https://github.com/affaan-m/agentshield))
+
+## Güvenlik Kaynakları
+
+- **AgentShield**: Agent konfigürasyonunuzu güvenlik açıkları için tarayın — `npx ecc-agentshield scan`
+- **Güvenlik Kılavuzu**: [The Shorthand Guide to Everything Agentic Security](./the-security-guide.md)
+- **OWASP MCP Top 10**: [owasp.org/www-project-mcp-top-10](https://owasp.org/www-project-mcp-top-10/)
+- **OWASP Agentic Applications Top 10**: [genai.owasp.org](https://genai.owasp.org/resource/owasp-top-10-for-agentic-applications-for-2026/)
diff --git a/docs/tr/SPONSORING.md b/docs/tr/SPONSORING.md
new file mode 100644
index 00000000..bbfb0912
--- /dev/null
+++ b/docs/tr/SPONSORING.md
@@ -0,0 +1,43 @@
+# ECC'ye Sponsor Olma
+
+ECC, Claude Code, Cursor, OpenCode ve Codex app/CLI genelinde açık kaynaklı bir ajan performans sistemi olarak sürdürülmektedir.
+
+## Neden Sponsor Olmalı
+
+Sponsorluk doğrudan şunları destekler:
+
+- Daha hızlı hata düzeltme ve sürüm döngüleri
+- Harness'lar arasında platformlar arası eşitlik çalışması
+- Topluluk için ücretsiz kalan genel dokümantasyon, beceriler ve güvenilirlik araçları
+
+## Sponsorluk Seviyeleri
+
+Bunlar pratik başlangıç noktalarıdır ve ortaklık kapsamına göre ayarlanabilir.
+
+| Seviye | Fiyat | En Uygun Olduğu | İçerikler |
+|------|-------|----------|----------|
+| Pilot Partner | $200/ay | İlk sponsor katılımı | Aylık metrik güncelleme, yol haritası önizlemesi, öncelikli bakımcı geri bildirimi |
+| Growth Partner | $500/ay | ECC'yi aktif olarak benimseyen ekipler | Pilot avantajları + aylık ofis saatleri senkronizasyonu + iş akışı entegrasyon rehberliği |
+| Strategic Partner | $1,000+/ay | Platform/ekosistem ortaklıkları | Growth avantajları + koordineli başlatma desteği + daha derin bakımcı işbirliği |
+
+## Sponsor Raporlaması
+
+Aylık paylaşılan metrikler şunları içerebilir:
+
+- npm indirmeleri (`ecc-universal`, `ecc-agentshield`)
+- Repository benimseme (yıldızlar, fork'lar, katkıda bulunanlar)
+- GitHub App kurulum trendi
+- Sürüm ritmi ve güvenilirlik kilometre taşları
+
+Kesin komut parçacıkları ve tekrarlanabilir çekme süreci için [`docs/business/metrics-and-sponsorship.md`](../business/metrics-and-sponsorship.md) dosyasına bakın.
+
+## Beklentiler ve Kapsam
+
+- Sponsorluk bakım ve hızlandırmayı destekler; proje sahipliğini transfer etmez.
+- Özellik istekleri sponsor seviyesi, ekosistem etkisi ve bakım riskine göre önceliklendirilir.
+- Güvenlik ve güvenilirlik düzeltmeleri yepyeni özelliklerden önce gelir.
+
+## Buradan Sponsor Olun
+
+- GitHub Sponsors: [https://github.com/sponsors/affaan-m](https://github.com/sponsors/affaan-m)
+- Proje sitesi: [https://ecc.tools](https://ecc.tools)
diff --git a/docs/tr/SPONSORS.md b/docs/tr/SPONSORS.md
new file mode 100644
index 00000000..74100c5f
--- /dev/null
+++ b/docs/tr/SPONSORS.md
@@ -0,0 +1,59 @@
+# Sponsorlar
+
+Bu projeye sponsor olan herkese teşekkürler! Desteğiniz ECC ekosisteminin büyümesini sağlıyor.
+
+## Kurumsal Sponsorlar
+
+*Burada yer almak için [Kurumsal sponsor](https://github.com/sponsors/affaan-m) olun*
+
+## İşletme Sponsorları
+
+*Burada yer almak için [İşletme sponsoru](https://github.com/sponsors/affaan-m) olun*
+
+## Takım Sponsorları
+
+*Burada yer almak için [Takım sponsoru](https://github.com/sponsors/affaan-m) olun*
+
+## Bireysel Sponsorlar
+
+*Burada listelenmek için [sponsor](https://github.com/sponsors/affaan-m) olun*
+
+---
+
+## Neden Sponsor Olmalı?
+
+Sponsorluğunuz şunlara yardımcı olur:
+
+- **Daha hızlı teslimat** — Araçlar ve özellikler geliştirmeye daha fazla zaman ayrılması
+- **Ücretsiz kalmasını sağlama** — Premium özellikler herkes için ücretsiz katmanı finanse eder
+- **Daha iyi destek** — Sponsorlar öncelikli yanıtlar alır
+- **Yol haritasını şekillendirme** — Pro+ sponsorlar özelliklere oy verir
+
+## Sponsor Hazırlık Sinyalleri
+
+Sponsor konuşmalarında bu kanıt noktalarını kullanın:
+
+- `ecc-universal` ve `ecc-agentshield` için canlı npm kurulum/indirme metrikleri
+- Marketplace kurulumları aracılığıyla GitHub App dağıtımı
+- Genel benimseme sinyalleri: yıldızlar, fork'lar, katkıda bulunanlar, sürüm ritmi
+- Harness'lar arası destek: Claude Code, Cursor, OpenCode, Codex app/CLI
+
+Kopyala/yapıştır metrik çekme iş akışı için [`docs/business/metrics-and-sponsorship.md`](../business/metrics-and-sponsorship.md) dosyasına bakın.
+
+## Sponsor Seviyeleri
+
+| Seviye | Fiyat | Avantajlar |
+|------|-------|----------|
+| Supporter | $5/ay | README'de isim, erken erişim |
+| Builder | $10/ay | Premium araç erişimi |
+| Pro | $25/ay | Öncelikli destek, ofis saatleri |
+| Team | $100/ay | 5 koltuk, takım yapılandırmaları |
+| Harness Partner | $200/ay | Aylık yol haritası senkronizasyonu, öncelikli bakımcı geri bildirimi, sürüm notlarında bahis |
+| Business | $500/ay | 25 koltuk, danışmanlık kredisi |
+| Enterprise | $2K/ay | Sınırsız koltuk, özel araçlar |
+
+[**Sponsor Olun →**](https://github.com/sponsors/affaan-m)
+
+---
+
+*Otomatik güncellenir. Son senkronizasyon: Şubat 2026*
diff --git a/docs/tr/TERMINOLOGY.md b/docs/tr/TERMINOLOGY.md
new file mode 100644
index 00000000..df2c16f5
--- /dev/null
+++ b/docs/tr/TERMINOLOGY.md
@@ -0,0 +1,184 @@
+# Terminoloji Tablosu (Terminology Glossary)
+
+Bu doküman Türkçe çevirilerin terminoloji karşılıklarını kayıt altına alarak çeviri tutarlılığını sağlar.
+
+## Durum Açıklaması
+
+- **Onaylandı (Confirmed)**: Onaylanmış çeviri
+- **Beklemede (Pending)**: İnceleme bekleyen çeviri
+
+---
+
+## Terminoloji Tablosu
+
+| English | tr | Durum | Notlar |
+|---------|-------|------|------|
+| Agent | Agent | Onaylandı | İngilizce tutulur |
+| Hook | Hook | Onaylandı | İngilizce tutulur |
+| Plugin | Plugin | Onaylandı | İngilizce tutulur |
+| Token | Token | Onaylandı | İngilizce tutulur |
+| Skill | Skill | Onaylandı | İngilizce tutulur |
+| Command | Command | Onaylandı | İngilizce tutulur |
+| Rule | Rule | Onaylandı | İngilizce tutulur |
+| Harness | Harness | Onaylandı | İngilizce tutulur |
+| TDD (Test-Driven Development) | TDD (Test Odaklı Geliştirme) | Onaylandı | İlk kullanımda açılır |
+| E2E (End-to-End) | E2E (Uçtan Uca) | Onaylandı | İlk kullanımda açılır |
+| API | API | Onaylandı | İngilizce tutulur |
+| CLI | CLI | Onaylandı | İngilizce tutulur |
+| IDE | IDE | Onaylandı | İngilizce tutulur |
+| MCP (Model Context Protocol) | MCP | Onaylandı | İngilizce tutulur |
+| Workflow | İş akışı / Workflow | Onaylandı | Bağlama göre |
+| Codebase | Kod tabanı / Codebase | Onaylandı | Bağlama göre |
+| Coverage | Kapsam / Coverage | Onaylandı | Test bağlamında |
+| Build | Build | Onaylandı | İngilizce tutulur |
+| Debug | Debug | Onaylandı | İngilizce tutulur |
+| Deploy | Deploy / Dağıtım | Onaylandı | Bağlama göre |
+| Commit | Commit | Onaylandı | Git terimi, İngilizce tutulur |
+| PR (Pull Request) | PR | Onaylandı | İngilizce tutulur |
+| Branch | Branch | Onaylandı | Git terimi, İngilizce tutulur |
+| Merge | Merge | Onaylandı | Git terimi, İngilizce tutulur |
+| Repository | Repository | Onaylandı | İngilizce tutulur |
+| Fork | Fork | Onaylandı | İngilizce tutulur |
+| Supabase | Supabase | - | Ürün adı korunur |
+| Redis | Redis | - | Ürün adı korunur |
+| Playwright | Playwright | - | Ürün adı korunur |
+| TypeScript | TypeScript | - | Dil adı korunur |
+| JavaScript | JavaScript | - | Dil adı korunur |
+| Go/Golang | Go | - | Dil adı korunur |
+| Python | Python | - | Dil adı korunur |
+| Java | Java | - | Dil adı korunur |
+| Kotlin | Kotlin | - | Dil adı korunur |
+| Swift | Swift | - | Dil adı korunur |
+| Rust | Rust | - | Dil adı korunur |
+| PHP | PHP | - | Dil adı korunur |
+| Perl | Perl | - | Dil adı korunur |
+| React | React | - | Framework adı korunur |
+| Next.js | Next.js | - | Framework adı korunur |
+| Vue | Vue | - | Framework adı korunur |
+| Django | Django | - | Framework adı korunur |
+| Laravel | Laravel | - | Framework adı korunur |
+| PostgreSQL | PostgreSQL | - | Ürün adı korunur |
+| SQLite | SQLite | - | Ürün adı korunur |
+| RLS (Row Level Security) | RLS (Satır Düzeyi Güvenlik) | Onaylandı | İlk kullanımda açılır |
+| OWASP | OWASP | - | İngilizce tutulur |
+| XSS | XSS | - | İngilizce tutulur |
+| SQL Injection | SQL Injection | Onaylandı | İngilizce tutulur |
+| CSRF | CSRF | - | İngilizce tutulur |
+| Refactor | Refactor / Yeniden yapılandırma | Onaylandı | Bağlama göre |
+| Dead Code | Dead code | Onaylandı | İngilizce tutulur |
+| Lint/Linter | Lint | Onaylandı | İngilizce tutulur |
+| Code Review | Code review | Onaylandı | İngilizce tutulur |
+| Security Review | Güvenlik incelemesi | Onaylandı | |
+| Best Practices | En iyi uygulamalar | Onaylandı | |
+| Edge Case | Edge case | Onaylandı | İngilizce tutulur |
+| Happy Path | Happy path | Onaylandı | İngilizce tutulur |
+| Fallback | Fallback | Onaylandı | İngilizce tutulur |
+| Cache | Cache | Onaylandı | İngilizce tutulur |
+| Queue | Queue | Onaylandı | İngilizce tutulur |
+| Pagination | Pagination | Onaylandı | İngilizce tutulur |
+| Cursor | Cursor | Onaylandı | İngilizce tutulur |
+| Index | Index | Onaylandı | İngilizce tutulur |
+| Schema | Schema | Onaylandı | İngilizce tutulur |
+| Migration | Migration | Onaylandı | İngilizce tutulur |
+| Transaction | Transaction | Onaylandı | İngilizce tutulur |
+| Concurrency | Eşzamanlılık / Concurrency | Onaylandı | Bağlama göre |
+| Goroutine | Goroutine | - | Go terimi korunur |
+| Channel | Channel | Onaylandı | Go bağlamında korunur |
+| Mutex | Mutex | - | İngilizce tutulur |
+| Interface | Interface | Onaylandı | İngilizce tutulur |
+| Struct | Struct | - | Go terimi korunur |
+| Mock | Mock | Onaylandı | Test terimi korunur |
+| Stub | Stub | Onaylandı | Test terimi korunur |
+| Fixture | Fixture | Onaylandı | Test terimi korunur |
+| Assertion | Assertion | Onaylandı | İngilizce tutulur |
+| Snapshot | Snapshot | Onaylandı | İngilizce tutulur |
+| Trace | Trace | Onaylandı | İngilizce tutulur |
+| Artifact | Artifact | Onaylandı | İngilizce tutulur |
+| CI/CD | CI/CD | - | İngilizce tutulur |
+| Pipeline | Pipeline | Onaylandı | İngilizce tutulur |
+| Container | Container | Onaylandı | İngilizce tutulur |
+| Docker | Docker | - | Ürün adı korunur |
+| Kubernetes | Kubernetes | - | Ürün adı korunur |
+| Sandbox | Sandbox | Onaylandı | İngilizce tutulur |
+| Evaluation / Eval | Eval | Onaylandı | İngilizce tutulur |
+| Prompt | Prompt | Onaylandı | İngilizce tutulur |
+| Context | Context / Bağlam | Onaylandı | Bağlama göre |
+| Subagent | Subagent | Onaylandı | İngilizce tutulur |
+| Orchestration | Orkestrasyon | Onaylandı | |
+| Checkpoint | Checkpoint | Onaylandı | İngilizce tutulur |
+| Verification Loop | Verification loop | Onaylandı | İngilizce tutulur |
+| Observer | Observer | Onaylandı | İngilizce tutulur |
+| Session | Session / Oturum | Onaylandı | Bağlama göre |
+| State | State / Durum | Onaylandı | Bağlama göre |
+| Memory | Memory / Bellek | Onaylandı | Bağlama göre |
+| Instinct | Instinct | Onaylandı | İngilizce tutulur |
+| Pattern | Pattern / Desen | Onaylandı | Bağlama göre |
+| Worktree | Worktree | Onaylandı | Git terimi, İngilizce tutulur |
+| Pass@k | Pass@k | - | Metrik adı korunur |
+| Grader | Grader | Onaylandı | İngilizce tutulur |
+| Hot-load | Hot-load | Onaylandı | İngilizce tutulur |
+| Cascade | Cascade | Onaylandı | İngilizce tutulur |
+| Throttling | Throttling | Onaylandı | İngilizce tutulur |
+| Sanitization | Sanitizasyon | Onaylandı | |
+| CVE | CVE | - | İngilizce tutulur |
+| AgentShield | AgentShield | - | Ürün adı korunur |
+| NanoClaw | NanoClaw | - | Ürün adı korunur |
+| ECC Tools | ECC Tools | - | Ürün adı korunur |
+
+---
+
+## Çeviri İlkeleri
+
+1. **Ürün Adları**: İngilizce tutulur (Supabase, Redis, Playwright, AgentShield)
+2. **Programlama Dilleri**: İngilizce tutulur (TypeScript, Go, JavaScript, Python)
+3. **Framework Adları**: İngilizce tutulur (React, Next.js, Vue, Django)
+4. **Teknik Kısaltmalar**: İngilizce tutulur (API, CLI, IDE, MCP, TDD, E2E, CI/CD)
+5. **Git Terimleri**: Çoğunlukla İngilizce tutulur (commit, PR, fork, branch, merge)
+6. **ECC Terimleri**: İngilizce tutulur (agent, hook, skill, command, rule, harness)
+7. **Kod İçeriği**: Çevrilmez (değişken adları, fonksiyon adları orijinal haliyle, açıklama yorumları çevrilir)
+8. **İlk Kullanım**: Kısaltmalar ilk kullanımda açılır
+9. **Bağlamsal Terimler**: Bazı terimler bağlama göre Türkçe veya İngilizce kullanılır (workflow, codebase, context, vb.)
+
+---
+
+## Türkçe Çeviri Notları
+
+### Neden Çoğu Terim İngilizce?
+
+Yazılım geliştirme ekosisteminde, özellikle AI agent harness sistemlerinde kullanılan terimler için Türkçe karşılıklar:
+
+1. **Tam karşılık vermez**: Örneğin "agent" kelimesinin Türkçe karşılığı olan "ajan" veya "temsilci" teknik bağlamda farklı anlamlara gelebilir.
+
+2. **Ekosistem bütünlüğü**: Geliştiriciler bu terimleri İngilizce olarak öğreniyor ve kullanıyor. Türkçeleştirmek kafa karışıklığına yol açabilir.
+
+3. **Dokümantasyon uyumu**: Orijinal Claude Code dokümantasyonu ve topluluk kaynaklarıyla uyum için İngilizce terimler korunur.
+
+4. **Kod-doküman tutarlılığı**: Kod içinde bu terimler İngilizce kullanıldığından, dokümantasyonda da aynı terimleri kullanmak tutarlılık sağlar.
+
+### Bağlamsal Kullanım
+
+Bazı terimler bağlama göre Türkçe veya İngilizce kullanılır:
+
+- **Workflow**: Genel anlatımda "iş akışı", teknik bağlamda "workflow"
+- **Context**: Genel anlatımda "bağlam", teknik bağlamda "context"
+- **Session**: Genel anlatımda "oturum", teknik bağlamda "session"
+- **Deploy**: Fiil olarak kullanıldığında "dağıtım yapmak", isim olarak "deploy"
+
+### Telaffuz Rehberi (Opsiyonel)
+
+Türkçe konuşurken yaygın kullanılan telaffuzlar:
+
+- **Agent**: /eycent/ (İngilizce telaffuz)
+- **Hook**: /huk/ (İngilizce telaffuz)
+- **Skill**: /skil/ (İngilizce telaffuz)
+- **Command**: /komand/ veya /kumand/
+- **Build**: /bild/
+- **Debug**: /dibag/
+- **Cache**: /keş/
+- **Pipeline**: /payplayn/ veya /paypalayn/
+
+---
+
+## Güncelleme Geçmişi
+
+- 2026-03-22: İlk sürüm oluşturuldu, tüm çeviri dosyalarında kullanılan terimler derlendi
diff --git a/docs/tr/TROUBLESHOOTING.md b/docs/tr/TROUBLESHOOTING.md
new file mode 100644
index 00000000..866bfae6
--- /dev/null
+++ b/docs/tr/TROUBLESHOOTING.md
@@ -0,0 +1,422 @@
+# Sorun Giderme Rehberi
+
+Everything Claude Code (ECC) eklentisi için yaygın sorunlar ve çözümler.
+
+## İçindekiler
+
+- [Bellek ve Context Sorunları](#bellek-ve-context-sorunları)
+- [Ajan Harness Hataları](#ajan-harness-hataları)
+- [Hook ve İş Akışı Hataları](#hook-ve-iş-akışı-hataları)
+- [Kurulum ve Yapılandırma](#kurulum-ve-yapılandırma)
+- [Performans Sorunları](#performans-sorunları)
+- [Yaygın Hata Mesajları](#yaygın-hata-mesajları)
+- [Yardım Alma](#yardım-alma)
+
+---
+
+## Bellek ve Context Sorunları
+
+### Context Window Taşması
+
+**Belirti:** "Context too long" hataları veya eksik yanıtlar
+
+**Nedenler:**
+- Token limitlerini aşan büyük dosya yüklemeleri
+- Birikmiş konuşma geçmişi
+- Tek oturumda birden fazla büyük araç çıktısı
+
+**Çözümler:**
+```bash
+# 1. Konuşma geçmişini temizle ve yeni başla
+# Claude Code kullan: "New Chat" veya Cmd/Ctrl+Shift+N
+
+# 2. Analiz öncesi dosya boyutunu küçült
+head -n 100 large-file.log > sample.log
+
+# 3. Büyük çıktılar için streaming kullan
+head -n 50 large-file.txt
+
+# 4. Görevleri daha küçük parçalara böl
+# Bunun yerine: "50 dosyanın hepsini analiz et"
+# Kullan: "src/components/ dizinindeki dosyaları analiz et"
+```
+
+### Bellek Kalıcılığı Hataları
+
+**Belirti:** Ajan önceki context veya gözlemleri hatırlamıyor
+
+**Nedenler:**
+- Devre dışı bırakılmış sürekli öğrenme hook'ları
+- Bozuk gözlem dosyaları
+- Proje algılama hataları
+
+**Çözümler:**
+```bash
+# Gözlemlerin kaydedilip kaydedilmediğini kontrol et
+ls ~/.claude/homunculus/projects/*/observations.jsonl
+
+# Mevcut projenin hash id'sini bul
+python3 - <<'PY'
+import json, os
+registry_path = os.path.expanduser("~/.claude/homunculus/projects.json")
+with open(registry_path) as f:
+ registry = json.load(f)
+for project_id, meta in registry.items():
+ if meta.get("root") == os.getcwd():
+ print(project_id)
+ break
+else:
+ raise SystemExit("Project hash not found in ~/.claude/homunculus/projects.json")
+PY
+
+# O proje için son gözlemleri görüntüle
+tail -20 ~/.claude/homunculus/projects/Yeni bir skill veya agent'a nasıl katkıda bulunurum?
+ +[CONTRIBUTING.md](../../CONTRIBUTING.md)'ye bakın. Kısa versiyon: +1. Repo'yu fork'layın +2. `skills/your-skill-name/SKILL.md` içinde skill'inizi oluşturun (YAML frontmatter ile) +3. Veya `agents/your-agent.md` içinde bir agent oluşturun +4. Ne yaptığını ve ne zaman kullanılacağını açıklayan net bir açıklamayla PR gönderin +{userComment}
+```
+
+### Kod Kalitesi (HIGH)
+
+- **Büyük fonksiyonlar** (>50 satır) — Daha küçük, odaklı fonksiyonlara bölün
+- **Büyük dosyalar** (>800 satır) — Sorumluluklara göre modüller çıkarın
+- **Derin iç içe geçme** (>4 seviye) — Erken return'ler, yardımcı çıkarımlar kullanın
+- **Eksik hata yönetimi** — İşlenmemiş promise rejection'ları, boş catch blokları
+- **Mutation kalıpları** — Immutable operasyonları tercih edin (spread, map, filter)
+- **console.log ifadeleri** — Merge'den önce debug loglamayı kaldırın
+- **Eksik testler** — Test kapsamı olmadan yeni kod yolları
+- **Ölü kod** — Yorum satırına alınmış kod, kullanılmayan import'lar, erişilemeyen dallar
+
+```typescript
+// KÖTÜ: Derin iç içe geçme + mutation
+function processUsers(users) {
+ if (users) {
+ for (const user of users) {
+ if (user.active) {
+ if (user.email) {
+ user.verified = true; // mutation!
+ results.push(user);
+ }
+ }
+ }
+ }
+ return results;
+}
+
+// İYİ: Erken return'ler + immutability + düz
+function processUsers(users) {
+ if (!users) return [];
+ return users
+ .filter(user => user.active && user.email)
+ .map(user => ({ ...user, verified: true }));
+}
+```
+
+### React/Next.js Kalıpları (HIGH)
+
+React/Next.js kodunu incelerken, ayrıca kontrol edin:
+
+- **Eksik dependency dizileri** — Eksik deps ile `useEffect`/`useMemo`/`useCallback`
+- **Render sırasında state güncellemeleri** — Render sırasında setState çağırmak sonsuz döngülere neden olur
+- **Listelerde eksik key'ler** — Öğeler yeniden sıralanabildiğinde key olarak dizi indeksi kullanma
+- **Prop drilling** — 3+ seviye geçirilen prop'lar (context veya composition kullan)
+- **Gereksiz yeniden render'lar** — Pahalı hesaplamalar için eksik memoization
+- **Client/server sınırı** — Server Component'lerinde `useState`/`useEffect` kullanma
+- **Eksik loading/error durumları** — Yedek UI olmadan veri çekme
+- **Stale closure'lar** — Eski state değerlerini yakalayan event handler'lar
+
+```tsx
+// KÖTÜ: Eksik dependency, stale closure
+useEffect(() => {
+ fetchData(userId);
+}, []); // userId deps'ten eksik
+
+// İYİ: Tam bağımlılıklar
+useEffect(() => {
+ fetchData(userId);
+}, [userId]);
+```
+
+```tsx
+// KÖTÜ: Yeniden sıralanabilir liste ile key olarak indeks kullanma
+{items.map((item, i) => {children}
+}
+
+export function CardHeader({ children }: { children: React.ReactNode }) {
+ return {children}
+}
+
+export function CardBody({ children }: { children: React.ReactNode }) {
+ return {children}
+}
+
+// Kullanım
+{children}
+}
+
+export function Tab({ id, children }: { id: string, children: React.ReactNode }) {
+ const context = useContext(TabsContext)
+ if (!context) throw new Error('Tab must be used within Tabs')
+
+ return (
+
+ )
+}
+
+// Kullanım
+
+
+ )
+})
+```
+
+### Code Splitting ve Lazy Loading
+
+```typescript
+import { lazy, Suspense } from 'react'
+
+// ✅ Ağır bileşenleri lazy yükle
+const HeavyChart = lazy(() => import('./HeavyChart'))
+const ThreeJsBackground = lazy(() => import('./ThreeJsBackground'))
+
+export function Dashboard() {
+ return (
+ {market.name}
+{market.description}
+
+
+
+
+ )
+}
+```
+
+### Uzun Listeler için Virtualization
+
+```typescript
+import { useVirtualizer } from '@tanstack/react-virtual'
+
+export function VirtualMarketList({ markets }: { markets: Market[] }) {
+ const parentRef = useRef
+
+ )
+}
+```
+
+## Form İşleme Kalıpları
+
+### Doğrulamalı Controlled Form
+
+```typescript
+interface FormData {
+ name: string
+ description: string
+ endDate: string
+}
+
+interface FormErrors {
+ name?: string
+ description?: string
+ endDate?: string
+}
+
+export function CreateMarketForm() {
+ const [formData, setFormData] = useState
+ {virtualizer.getVirtualItems().map(virtualRow => (
+
+
+
+ ))}
+
+
+ )
+ }
+
+ return this.props.children
+ }
+}
+
+// Kullanım
+Bir şeyler yanlış gitti
+{this.state.error?.message}
+ +
+ {/* Dropdown implementasyonu */}
+
+ )
+}
+```
+
+### Focus Yönetimi
+
+```typescript
+export function Modal({ isOpen, onClose, children }: ModalProps) {
+ const modalRef = useRef e.key === 'Escape' && onClose()}
+ >
+ {children}
+
+ ) : null
+}
+```
+
+**Unutmayın**: Modern frontend kalıpları sürdürülebilir, performanslı kullanıcı arayüzleri sağlar. Proje karmaşıklığınıza uyan kalıpları seçin.
diff --git a/docs/tr/skills/golang-patterns/SKILL.md b/docs/tr/skills/golang-patterns/SKILL.md
new file mode 100644
index 00000000..9ebc648c
--- /dev/null
+++ b/docs/tr/skills/golang-patterns/SKILL.md
@@ -0,0 +1,674 @@
+---
+name: golang-patterns
+description: İdiomatic Go desenler, en iyi uygulamalar ve sağlam, verimli ve bakımı kolay Go uygulamaları oluşturmak için konvansiyonlar.
+origin: ECC
+---
+
+# Go Geliştirme Desenleri
+
+Sağlam, verimli ve bakımı kolay uygulamalar oluşturmak için idiomatic Go desenleri ve en iyi uygulamalar.
+
+## Ne Zaman Etkinleştirmeli
+
+- Yeni Go kodu yazarken
+- Go kodunu gözden geçirirken
+- Mevcut Go kodunu refactor ederken
+- Go paketleri/modülleri tasarlarken
+
+## Temel Prensipler
+
+### 1. Basitlik ve Açıklık
+
+Go, zekiceden ziyade basitliği tercih eder. Kod açık ve okunması kolay olmalıdır.
+
+```go
+// İyi: Açık ve doğrudan
+func GetUser(id string) (*User, error) {
+ user, err := db.FindUser(id)
+ if err != nil {
+ return nil, fmt.Errorf("get user %s: %w", id, err)
+ }
+ return user, nil
+}
+
+// Kötü: Aşırı zeki
+func GetUser(id string) (*User, error) {
+ return func() (*User, error) {
+ if u, e := db.FindUser(id); e == nil {
+ return u, nil
+ } else {
+ return nil, e
+ }
+ }()
+}
+```
+
+### 2. Sıfır Değeri Kullanışlı Yapın
+
+Türleri, sıfır değerinin başlatma olmadan hemen kullanılabilir olacağı şekilde tasarlayın.
+
+```go
+// İyi: Sıfır değer kullanışlıdır
+type Counter struct {
+ mu sync.Mutex
+ count int // sıfır değer 0'dır, kullanıma hazırdır
+}
+
+func (c *Counter) Inc() {
+ c.mu.Lock()
+ c.count++
+ c.mu.Unlock()
+}
+
+// İyi: bytes.Buffer sıfır değerle çalışır
+var buf bytes.Buffer
+buf.WriteString("hello")
+
+// Kötü: Başlatma gerektirir
+type BadCounter struct {
+ counts map[string]int // nil map panic verir
+}
+```
+
+### 3. Interface Kabul Et, Struct Döndür
+
+Fonksiyonlar interface parametreleri kabul etmeli ve somut tipler döndürmelidir.
+
+```go
+// İyi: Interface kabul eder, somut tip döndürür
+func ProcessData(r io.Reader) (*Result, error) {
+ data, err := io.ReadAll(r)
+ if err != nil {
+ return nil, err
+ }
+ return &Result{Data: data}, nil
+}
+
+// Kötü: Interface döndürür (implementasyon detaylarını gereksiz yere gizler)
+func ProcessData(r io.Reader) (io.Reader, error) {
+ // ...
+}
+```
+
+## Hata İşleme Desenleri
+
+### Bağlam ile Hata Sarmalama
+
+```go
+// İyi: Hataları bağlamla sarmalayın
+func LoadConfig(path string) (*Config, error) {
+ data, err := os.ReadFile(path)
+ if err != nil {
+ return nil, fmt.Errorf("load config %s: %w", path, err)
+ }
+
+ var cfg Config
+ if err := json.Unmarshal(data, &cfg); err != nil {
+ return nil, fmt.Errorf("parse config %s: %w", path, err)
+ }
+
+ return &cfg, nil
+}
+```
+
+### Özel Hata Tipleri
+
+```go
+// Domain'e özgü hataları tanımlayın
+type ValidationError struct {
+ Field string
+ Message string
+}
+
+func (e *ValidationError) Error() string {
+ return fmt.Sprintf("validation failed on %s: %s", e.Field, e.Message)
+}
+
+// Yaygın durumlar için sentinel hatalar
+var (
+ ErrNotFound = errors.New("resource not found")
+ ErrUnauthorized = errors.New("unauthorized")
+ ErrInvalidInput = errors.New("invalid input")
+)
+```
+
+### errors.Is ve errors.As ile Hata Kontrolü
+
+```go
+func HandleError(err error) {
+ // Belirli bir hatayı kontrol et
+ if errors.Is(err, sql.ErrNoRows) {
+ log.Println("No records found")
+ return
+ }
+
+ // Hata tipini kontrol et
+ var validationErr *ValidationError
+ if errors.As(err, &validationErr) {
+ log.Printf("Validation error on field %s: %s",
+ validationErr.Field, validationErr.Message)
+ return
+ }
+
+ // Bilinmeyen hata
+ log.Printf("Unexpected error: %v", err)
+}
+```
+
+### Hataları Asla Göz Ardı Etmeyin
+
+```go
+// Kötü: Boş tanımlayıcı ile hatayı göz ardı etmek
+result, _ := doSomething()
+
+// İyi: Hatayı işleyin veya neden göz ardı edildiğini açıkça belgelendirin
+result, err := doSomething()
+if err != nil {
+ return err
+}
+
+// Kabul edilebilir: Hata gerçekten önemli olmadığında (nadir)
+_ = writer.Close() // En iyi çaba temizliği, hata başka yerde loglanır
+```
+
+## Eşzamanlılık Desenleri
+
+### Worker Pool
+
+```go
+func WorkerPool(jobs <-chan Job, results chan<- Result, numWorkers int) {
+ var wg sync.WaitGroup
+
+ for i := 0; i < numWorkers; i++ {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ for job := range jobs {
+ results <- process(job)
+ }
+ }()
+ }
+
+ wg.Wait()
+ close(results)
+}
+```
+
+### İptal ve Zaman Aşımları için Context
+
+```go
+func FetchWithTimeout(ctx context.Context, url string) ([]byte, error) {
+ ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+ defer cancel()
+
+ req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+ if err != nil {
+ return nil, fmt.Errorf("create request: %w", err)
+ }
+
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ return nil, fmt.Errorf("fetch %s: %w", url, err)
+ }
+ defer resp.Body.Close()
+
+ return io.ReadAll(resp.Body)
+}
+```
+
+### Zarif Kapatma
+
+```go
+func GracefulShutdown(server *http.Server) {
+ quit := make(chan os.Signal, 1)
+ signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+ <-quit
+ log.Println("Shutting down server...")
+
+ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+ defer cancel()
+
+ if err := server.Shutdown(ctx); err != nil {
+ log.Fatalf("Server forced to shutdown: %v", err)
+ }
+
+ log.Println("Server exited")
+}
+```
+
+### Koordineli Goroutine'ler için errgroup
+
+```go
+import "golang.org/x/sync/errgroup"
+
+func FetchAll(ctx context.Context, urls []string) ([][]byte, error) {
+ g, ctx := errgroup.WithContext(ctx)
+ results := make([][]byte, len(urls))
+
+ for i, url := range urls {
+ i, url := i, url // Loop değişkenlerini yakala
+ g.Go(func() error {
+ data, err := FetchWithTimeout(ctx, url)
+ if err != nil {
+ return err
+ }
+ results[i] = data
+ return nil
+ })
+ }
+
+ if err := g.Wait(); err != nil {
+ return nil, err
+ }
+ return results, nil
+}
+```
+
+### Goroutine Sızıntılarından Kaçınma
+
+```go
+// Kötü: Context iptal edilirse goroutine sızıntısı
+func leakyFetch(ctx context.Context, url string) <-chan []byte {
+ ch := make(chan []byte)
+ go func() {
+ data, _ := fetch(url)
+ ch <- data // Alıcı yoksa sonsuza kadar bloklar
+ }()
+ return ch
+}
+
+// İyi: İptali düzgün bir şekilde işler
+func safeFetch(ctx context.Context, url string) <-chan []byte {
+ ch := make(chan []byte, 1) // Tamponlu kanal
+ go func() {
+ data, err := fetch(url)
+ if err != nil {
+ return
+ }
+ select {
+ case ch <- data:
+ case <-ctx.Done():
+ }
+ }()
+ return ch
+}
+```
+
+## Interface Tasarımı
+
+### Küçük, Odaklanmış Interface'ler
+
+```go
+// İyi: Tek metodlu interface'ler
+type Reader interface {
+ Read(p []byte) (n int, err error)
+}
+
+type Writer interface {
+ Write(p []byte) (n int, err error)
+}
+
+type Closer interface {
+ Close() error
+}
+
+// Interface'leri gerektiği gibi birleştirin
+type ReadWriteCloser interface {
+ Reader
+ Writer
+ Closer
+}
+```
+
+### Interface'leri Kullanıldıkları Yerde Tanımlayın
+
+```go
+// Sağlayıcı pakette değil, tüketici pakette
+package service
+
+// UserStore bu servisin neye ihtiyacı olduğunu tanımlar
+type UserStore interface {
+ GetUser(id string) (*User, error)
+ SaveUser(user *User) error
+}
+
+type Service struct {
+ store UserStore
+}
+
+// Somut implementasyon başka bir pakette olabilir
+// Bu interface'i bilmesine gerek yoktur
+```
+
+### Type Assertion ile Opsiyonel Davranış
+
+```go
+type Flusher interface {
+ Flush() error
+}
+
+func WriteAndFlush(w io.Writer, data []byte) error {
+ if _, err := w.Write(data); err != nil {
+ return err
+ }
+
+ // Destekleniyorsa flush et
+ if f, ok := w.(Flusher); ok {
+ return f.Flush()
+ }
+ return nil
+}
+```
+
+## Paket Organizasyonu
+
+### Standart Proje Düzeni
+
+```text
+myproject/
+├── cmd/
+│ └── myapp/
+│ └── main.go # Giriş noktası
+├── internal/
+│ ├── handler/ # HTTP handler'lar
+│ ├── service/ # İş mantığı
+│ ├── repository/ # Veri erişimi
+│ └── config/ # Yapılandırma
+├── pkg/
+│ └── client/ # Public API client
+├── api/
+│ └── v1/ # API tanımları (proto, OpenAPI)
+├── testdata/ # Test fixture'ları
+├── go.mod
+├── go.sum
+└── Makefile
+```
+
+### Paket İsimlendirme
+
+```go
+// İyi: Kısa, küçük harf, alt çizgi yok
+package http
+package json
+package user
+
+// Kötü: Verbose, karışık büyük/küçük harf veya gereksiz
+package httpHandler
+package json_parser
+package userService // Gereksiz 'Service' eki
+```
+
+### Paket Seviyesi State'ten Kaçının
+
+```go
+// Kötü: Global değişken state
+var db *sql.DB
+
+func init() {
+ db, _ = sql.Open("postgres", os.Getenv("DATABASE_URL"))
+}
+
+// İyi: Dependency injection
+type Server struct {
+ db *sql.DB
+}
+
+func NewServer(db *sql.DB) *Server {
+ return &Server{db: db}
+}
+```
+
+## Struct Tasarımı
+
+### Functional Options Deseni
+
+```go
+type Server struct {
+ addr string
+ timeout time.Duration
+ logger *log.Logger
+}
+
+type Option func(*Server)
+
+func WithTimeout(d time.Duration) Option {
+ return func(s *Server) {
+ s.timeout = d
+ }
+}
+
+func WithLogger(l *log.Logger) Option {
+ return func(s *Server) {
+ s.logger = l
+ }
+}
+
+func NewServer(addr string, opts ...Option) *Server {
+ s := &Server{
+ addr: addr,
+ timeout: 30 * time.Second, // varsayılan
+ logger: log.Default(), // varsayılan
+ }
+ for _, opt := range opts {
+ opt(s)
+ }
+ return s
+}
+
+// Kullanım
+server := NewServer(":8080",
+ WithTimeout(60*time.Second),
+ WithLogger(customLogger),
+)
+```
+
+### Kompozisyon için Embedding
+
+```go
+type Logger struct {
+ prefix string
+}
+
+func (l *Logger) Log(msg string) {
+ fmt.Printf("[%s] %s\n", l.prefix, msg)
+}
+
+type Server struct {
+ *Logger // Embedding - Server Log metodunu alır
+ addr string
+}
+
+func NewServer(addr string) *Server {
+ return &Server{
+ Logger: &Logger{prefix: "SERVER"},
+ addr: addr,
+ }
+}
+
+// Kullanım
+s := NewServer(":8080")
+s.Log("Starting...") // Gömülü Logger.Log'u çağırır
+```
+
+## Bellek ve Performans
+
+### Boyut Bilindiğinde Slice'ları Önceden Tahsis Edin
+
+```go
+// Kötü: Slice'ı birden çok kez büyütür
+func processItems(items []Item) []Result {
+ var results []Result
+ for _, item := range items {
+ results = append(results, process(item))
+ }
+ return results
+}
+
+// İyi: Tek tahsis
+func processItems(items []Item) []Result {
+ results := make([]Result, 0, len(items))
+ for _, item := range items {
+ results = append(results, process(item))
+ }
+ return results
+}
+```
+
+### Sık Tahsisler için sync.Pool Kullanın
+
+```go
+var bufferPool = sync.Pool{
+ New: func() interface{} {
+ return new(bytes.Buffer)
+ },
+}
+
+func ProcessRequest(data []byte) []byte {
+ buf := bufferPool.Get().(*bytes.Buffer)
+ defer func() {
+ buf.Reset()
+ bufferPool.Put(buf)
+ }()
+
+ buf.Write(data)
+ // İşle...
+ return buf.Bytes()
+}
+```
+
+### Döngülerde String Birleştirmekten Kaçının
+
+```go
+// Kötü: Birçok string tahsisi oluşturur
+func join(parts []string) string {
+ var result string
+ for _, p := range parts {
+ result += p + ","
+ }
+ return result
+}
+
+// İyi: strings.Builder ile tek tahsis
+func join(parts []string) string {
+ var sb strings.Builder
+ for i, p := range parts {
+ if i > 0 {
+ sb.WriteString(",")
+ }
+ sb.WriteString(p)
+ }
+ return sb.String()
+}
+
+// En iyi: Standart kütüphaneyi kullanın
+func join(parts []string) string {
+ return strings.Join(parts, ",")
+}
+```
+
+## Go Tooling Entegrasyonu
+
+### Temel Komutlar
+
+```bash
+# Build ve çalıştır
+go build ./...
+go run ./cmd/myapp
+
+# Test
+go test ./...
+go test -race ./...
+go test -cover ./...
+
+# Statik analiz
+go vet ./...
+staticcheck ./...
+golangci-lint run
+
+# Modül yönetimi
+go mod tidy
+go mod verify
+
+# Formatlama
+gofmt -w .
+goimports -w .
+```
+
+### Önerilen Linter Yapılandırması (.golangci.yml)
+
+```yaml
+linters:
+ enable:
+ - errcheck
+ - gosimple
+ - govet
+ - ineffassign
+ - staticcheck
+ - unused
+ - gofmt
+ - goimports
+ - misspell
+ - unconvert
+ - unparam
+
+linters-settings:
+ errcheck:
+ check-type-assertions: true
+ govet:
+ check-shadowing: true
+
+issues:
+ exclude-use-default: false
+```
+
+## Hızlı Referans: Go İfadeleri
+
+| İfade | Açıklama |
+|-------|----------|
+| Interface kabul et, struct döndür | Fonksiyonlar interface parametreleri kabul eder, somut tipler döndürür |
+| Hatalar değerdir | Hataları exception değil birinci sınıf değerler olarak ele alın |
+| Belleği paylaşarak iletişim kurmayın | Goroutine'ler arası koordinasyon için kanalları kullanın |
+| Sıfır değeri kullanışlı yapın | Tipler açık başlatma olmadan çalışmalıdır |
+| Biraz kopyalama biraz bağımlılıktan iyidir | Gereksiz dış bağımlılıklardan kaçının |
+| Açık zekiden iyidir | Okunabilirliği zekiceden öncelikli kılın |
+| gofmt kimsenin favorisi değil ama herkesin arkadaşı | Her zaman gofmt/goimports ile formatlayın |
+| Erken dönün | Hataları önce işleyin, mutlu yolu girintilendirilmemiş tutun |
+
+## Kaçınılması Gereken Anti-Desenler
+
+```go
+// Kötü: Uzun fonksiyonlarda naked return'ler
+func process() (result int, err error) {
+ // ... 50 satır ...
+ return // Ne döndürülüyor?
+}
+
+// Kötü: Kontrol akışı için panic kullanmak
+func GetUser(id string) *User {
+ user, err := db.Find(id)
+ if err != nil {
+ panic(err) // Bunu yapmayın
+ }
+ return user
+}
+
+// Kötü: Struct içinde context geçmek
+type Request struct {
+ ctx context.Context // Context ilk parametre olmalı
+ ID string
+}
+
+// İyi: Context ilk parametre olarak
+func ProcessRequest(ctx context.Context, id string) error {
+ // ...
+}
+
+// Kötü: Value ve pointer receiver'ları karıştırmak
+type Counter struct{ n int }
+func (c Counter) Value() int { return c.n } // Value receiver
+func (c *Counter) Increment() { c.n++ } // Pointer receiver
+// Bir stil seçin ve tutarlı olun
+```
+
+**Unutmayın**: Go kodu en iyi anlamda sıkıcı olmalıdır - öngörülebilir, tutarlı ve anlaşılması kolay. Şüphe duyduğunuzda, basit tutun.
diff --git a/docs/tr/skills/golang-testing/SKILL.md b/docs/tr/skills/golang-testing/SKILL.md
new file mode 100644
index 00000000..f8ea2abe
--- /dev/null
+++ b/docs/tr/skills/golang-testing/SKILL.md
@@ -0,0 +1,720 @@
+---
+name: golang-testing
+description: Table-driven testler, subtestler, benchmark'lar, fuzzing ve test coverage içeren Go test desenleri. TDD metodolojisi ile idiomatic Go uygulamalarını takip eder.
+origin: ECC
+---
+
+# Go Test Desenleri
+
+TDD metodolojisini takip eden güvenilir, bakımı kolay testler yazmak için kapsamlı Go test desenleri.
+
+## Ne Zaman Etkinleştirmeli
+
+- Yeni Go fonksiyonları veya metodları yazarken
+- Mevcut koda test coverage eklerken
+- Performans-kritik kod için benchmark'lar oluştururken
+- Input validation için fuzz testler implement ederken
+- Go projelerinde TDD workflow'u takip ederken
+
+## Go için TDD Workflow'u
+
+### RED-GREEN-REFACTOR Döngüsü
+
+```
+RED → Önce başarısız bir test yaz
+GREEN → Testi geçirmek için minimal kod yaz
+REFACTOR → Testleri yeşil tutarken kodu iyileştir
+REPEAT → Sonraki gereksinimle devam et
+```
+
+### Go'da Adım Adım TDD
+
+```go
+// Adım 1: Interface/signature'ı tanımla
+// calculator.go
+package calculator
+
+func Add(a, b int) int {
+ panic("not implemented") // Placeholder
+}
+
+// Adım 2: Başarısız test yaz (RED)
+// calculator_test.go
+package calculator
+
+import "testing"
+
+func TestAdd(t *testing.T) {
+ got := Add(2, 3)
+ want := 5
+ if got != want {
+ t.Errorf("Add(2, 3) = %d; want %d", got, want)
+ }
+}
+
+// Adım 3: Testi çalıştır - FAIL'i doğrula
+// $ go test
+// --- FAIL: TestAdd (0.00s)
+// panic: not implemented
+
+// Adım 4: Minimal kodu implement et (GREEN)
+func Add(a, b int) int {
+ return a + b
+}
+
+// Adım 5: Testi çalıştır - PASS'i doğrula
+// $ go test
+// PASS
+
+// Adım 6: Gerekirse refactor et, testlerin hala geçtiğini doğrula
+```
+
+## Table-Driven Testler
+
+Go testleri için standart desen. Minimal kodla kapsamlı coverage sağlar.
+
+```go
+func TestAdd(t *testing.T) {
+ tests := []struct {
+ name string
+ a, b int
+ expected int
+ }{
+ {"positive numbers", 2, 3, 5},
+ {"negative numbers", -1, -2, -3},
+ {"zero values", 0, 0, 0},
+ {"mixed signs", -1, 1, 0},
+ {"large numbers", 1000000, 2000000, 3000000},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := Add(tt.a, tt.b)
+ if got != tt.expected {
+ t.Errorf("Add(%d, %d) = %d; want %d",
+ tt.a, tt.b, got, tt.expected)
+ }
+ })
+ }
+}
+```
+
+### Hata Durumları ile Table-Driven Testler
+
+```go
+func TestParseConfig(t *testing.T) {
+ tests := []struct {
+ name string
+ input string
+ want *Config
+ wantErr bool
+ }{
+ {
+ name: "valid config",
+ input: `{"host": "localhost", "port": 8080}`,
+ want: &Config{Host: "localhost", Port: 8080},
+ },
+ {
+ name: "invalid JSON",
+ input: `{invalid}`,
+ wantErr: true,
+ },
+ {
+ name: "empty input",
+ input: "",
+ wantErr: true,
+ },
+ {
+ name: "minimal config",
+ input: `{}`,
+ want: &Config{}, // Sıfır değer config
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got, err := ParseConfig(tt.input)
+
+ if tt.wantErr {
+ if err == nil {
+ t.Error("expected error, got nil")
+ }
+ return
+ }
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("got %+v; want %+v", got, tt.want)
+ }
+ })
+ }
+}
+```
+
+## Subtestler ve Sub-benchmark'lar
+
+### İlgili Testleri Organize Etme
+
+```go
+func TestUser(t *testing.T) {
+ // Tüm subtestler tarafından paylaşılan setup
+ db := setupTestDB(t)
+
+ t.Run("Create", func(t *testing.T) {
+ user := &User{Name: "Alice"}
+ err := db.CreateUser(user)
+ if err != nil {
+ t.Fatalf("CreateUser failed: %v", err)
+ }
+ if user.ID == "" {
+ t.Error("expected user ID to be set")
+ }
+ })
+
+ t.Run("Get", func(t *testing.T) {
+ user, err := db.GetUser("alice-id")
+ if err != nil {
+ t.Fatalf("GetUser failed: %v", err)
+ }
+ if user.Name != "Alice" {
+ t.Errorf("got name %q; want %q", user.Name, "Alice")
+ }
+ })
+
+ t.Run("Update", func(t *testing.T) {
+ // ...
+ })
+
+ t.Run("Delete", func(t *testing.T) {
+ // ...
+ })
+}
+```
+
+### Paralel Subtestler
+
+```go
+func TestParallel(t *testing.T) {
+ tests := []struct {
+ name string
+ input string
+ }{
+ {"case1", "input1"},
+ {"case2", "input2"},
+ {"case3", "input3"},
+ }
+
+ for _, tt := range tests {
+ tt := tt // Range değişkenini yakala
+ t.Run(tt.name, func(t *testing.T) {
+ t.Parallel() // Subtestleri paralel çalıştır
+ result := Process(tt.input)
+ // assertion'lar...
+ _ = result
+ })
+ }
+}
+```
+
+## Test Helper'ları
+
+### Helper Fonksiyonlar
+
+```go
+func setupTestDB(t *testing.T) *sql.DB {
+ t.Helper() // Bunu helper fonksiyon olarak işaretle
+
+ db, err := sql.Open("sqlite3", ":memory:")
+ if err != nil {
+ t.Fatalf("failed to open database: %v", err)
+ }
+
+ // Test bittiğinde temizlik
+ t.Cleanup(func() {
+ db.Close()
+ })
+
+ // Migration'ları çalıştır
+ if _, err := db.Exec(schema); err != nil {
+ t.Fatalf("failed to create schema: %v", err)
+ }
+
+ return db
+}
+
+func assertNoError(t *testing.T, err error) {
+ t.Helper()
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+}
+
+func assertEqual[T comparable](t *testing.T, got, want T) {
+ t.Helper()
+ if got != want {
+ t.Errorf("got %v; want %v", got, want)
+ }
+}
+```
+
+### Geçici Dosyalar ve Dizinler
+
+```go
+func TestFileProcessing(t *testing.T) {
+ // Geçici dizin oluştur - otomatik olarak temizlenir
+ tmpDir := t.TempDir()
+
+ // Test dosyası oluştur
+ testFile := filepath.Join(tmpDir, "test.txt")
+ err := os.WriteFile(testFile, []byte("test content"), 0644)
+ if err != nil {
+ t.Fatalf("failed to create test file: %v", err)
+ }
+
+ // Testi çalıştır
+ result, err := ProcessFile(testFile)
+ if err != nil {
+ t.Fatalf("ProcessFile failed: %v", err)
+ }
+
+ // Assert...
+ _ = result
+}
+```
+
+## Golden File'lar
+
+`testdata/` içinde saklanan beklenen çıktı dosyalarına karşı test etme.
+
+```go
+var update = flag.Bool("update", false, "update golden files")
+
+func TestRender(t *testing.T) {
+ tests := []struct {
+ name string
+ input Template
+ }{
+ {"simple", Template{Name: "test"}},
+ {"complex", Template{Name: "test", Items: []string{"a", "b"}}},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := Render(tt.input)
+
+ golden := filepath.Join("testdata", tt.name+".golden")
+
+ if *update {
+ // Golden dosyayı güncelle: go test -update
+ err := os.WriteFile(golden, got, 0644)
+ if err != nil {
+ t.Fatalf("failed to update golden file: %v", err)
+ }
+ }
+
+ want, err := os.ReadFile(golden)
+ if err != nil {
+ t.Fatalf("failed to read golden file: %v", err)
+ }
+
+ if !bytes.Equal(got, want) {
+ t.Errorf("output mismatch:\ngot:\n%s\nwant:\n%s", got, want)
+ }
+ })
+ }
+}
+```
+
+## Interface'ler ile Mocking
+
+### Interface Tabanlı Mocking
+
+```go
+// Bağımlılıklar için interface tanımlayın
+type UserRepository interface {
+ GetUser(id string) (*User, error)
+ SaveUser(user *User) error
+}
+
+// Production implementasyonu
+type PostgresUserRepository struct {
+ db *sql.DB
+}
+
+func (r *PostgresUserRepository) GetUser(id string) (*User, error) {
+ // Gerçek veritabanı sorgusu
+}
+
+// Testler için mock implementasyon
+type MockUserRepository struct {
+ GetUserFunc func(id string) (*User, error)
+ SaveUserFunc func(user *User) error
+}
+
+func (m *MockUserRepository) GetUser(id string) (*User, error) {
+ return m.GetUserFunc(id)
+}
+
+func (m *MockUserRepository) SaveUser(user *User) error {
+ return m.SaveUserFunc(user)
+}
+
+// Mock kullanarak test
+func TestUserService(t *testing.T) {
+ mock := &MockUserRepository{
+ GetUserFunc: func(id string) (*User, error) {
+ if id == "123" {
+ return &User{ID: "123", Name: "Alice"}, nil
+ }
+ return nil, ErrNotFound
+ },
+ }
+
+ service := NewUserService(mock)
+
+ user, err := service.GetUserProfile("123")
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if user.Name != "Alice" {
+ t.Errorf("got name %q; want %q", user.Name, "Alice")
+ }
+}
+```
+
+## Benchmark'lar
+
+### Temel Benchmark'lar
+
+```go
+func BenchmarkProcess(b *testing.B) {
+ data := generateTestData(1000)
+ b.ResetTimer() // Setup süresini sayma
+
+ for i := 0; i < b.N; i++ {
+ Process(data)
+ }
+}
+
+// Çalıştır: go test -bench=BenchmarkProcess -benchmem
+// Çıktı: BenchmarkProcess-8 10000 105234 ns/op 4096 B/op 10 allocs/op
+```
+
+### Farklı Boyutlarla Benchmark
+
+```go
+func BenchmarkSort(b *testing.B) {
+ sizes := []int{100, 1000, 10000, 100000}
+
+ for _, size := range sizes {
+ b.Run(fmt.Sprintf("size=%d", size), func(b *testing.B) {
+ data := generateRandomSlice(size)
+ b.ResetTimer()
+
+ for i := 0; i < b.N; i++ {
+ // Zaten sıralanmış veriyi sıralamaktan kaçınmak için kopya oluştur
+ tmp := make([]int, len(data))
+ copy(tmp, data)
+ sort.Ints(tmp)
+ }
+ })
+ }
+}
+```
+
+### Bellek Tahsis Benchmark'ları
+
+```go
+func BenchmarkStringConcat(b *testing.B) {
+ parts := []string{"hello", "world", "foo", "bar", "baz"}
+
+ b.Run("plus", func(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ var s string
+ for _, p := range parts {
+ s += p
+ }
+ _ = s
+ }
+ })
+
+ b.Run("builder", func(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ var sb strings.Builder
+ for _, p := range parts {
+ sb.WriteString(p)
+ }
+ _ = sb.String()
+ }
+ })
+
+ b.Run("join", func(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ _ = strings.Join(parts, "")
+ }
+ })
+}
+```
+
+## Fuzzing (Go 1.18+)
+
+### Temel Fuzz Testi
+
+```go
+func FuzzParseJSON(f *testing.F) {
+ // Seed corpus ekle
+ f.Add(`{"name": "test"}`)
+ f.Add(`{"count": 123}`)
+ f.Add(`[]`)
+ f.Add(`""`)
+
+ f.Fuzz(func(t *testing.T, input string) {
+ var result map[string]interface{}
+ err := json.Unmarshal([]byte(input), &result)
+
+ if err != nil {
+ // Rastgele input için geçersiz JSON beklenebilir
+ return
+ }
+
+ // Parsing başarılıysa, yeniden encoding çalışmalı
+ _, err = json.Marshal(result)
+ if err != nil {
+ t.Errorf("Marshal failed after successful Unmarshal: %v", err)
+ }
+ })
+}
+
+// Çalıştır: go test -fuzz=FuzzParseJSON -fuzztime=30s
+```
+
+### Birden Çok Input ile Fuzz Testi
+
+```go
+func FuzzCompare(f *testing.F) {
+ f.Add("hello", "world")
+ f.Add("", "")
+ f.Add("abc", "abc")
+
+ f.Fuzz(func(t *testing.T, a, b string) {
+ result := Compare(a, b)
+
+ // Özellik: Compare(a, a) her zaman 0'a eşit olmalı
+ if a == b && result != 0 {
+ t.Errorf("Compare(%q, %q) = %d; want 0", a, b, result)
+ }
+
+ // Özellik: Compare(a, b) ve Compare(b, a) zıt işarete sahip olmalı
+ reverse := Compare(b, a)
+ if (result > 0 && reverse >= 0) || (result < 0 && reverse <= 0) {
+ if result != 0 || reverse != 0 {
+ t.Errorf("Compare(%q, %q) = %d, Compare(%q, %q) = %d; inconsistent",
+ a, b, result, b, a, reverse)
+ }
+ }
+ })
+}
+```
+
+## Test Coverage
+
+### Coverage Çalıştırma
+
+```bash
+# Temel coverage
+go test -cover ./...
+
+# Coverage profili oluştur
+go test -coverprofile=coverage.out ./...
+
+# Coverage'ı tarayıcıda görüntüle
+go tool cover -html=coverage.out
+
+# Fonksiyona göre coverage görüntüle
+go tool cover -func=coverage.out
+
+# Race detection ile coverage
+go test -race -coverprofile=coverage.out ./...
+```
+
+### Coverage Hedefleri
+
+| Kod Tipi | Hedef |
+|----------|-------|
+| Kritik iş mantığı | 100% |
+| Public API'ler | 90%+ |
+| Genel kod | 80%+ |
+| Oluşturulan kod | Hariç tut |
+
+### Oluşturulan Kodu Coverage'dan Hariç Tutma
+
+```go
+//go:generate mockgen -source=interface.go -destination=mock_interface.go
+
+// Coverage profile'ında, build tag'leri ile hariç tut:
+// go test -cover -tags=!generate ./...
+```
+
+## HTTP Handler Testleri
+
+```go
+func TestHealthHandler(t *testing.T) {
+ // Request oluştur
+ req := httptest.NewRequest(http.MethodGet, "/health", nil)
+ w := httptest.NewRecorder()
+
+ // Handler'ı çağır
+ HealthHandler(w, req)
+
+ // Response'u kontrol et
+ resp := w.Result()
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ t.Errorf("got status %d; want %d", resp.StatusCode, http.StatusOK)
+ }
+
+ body, _ := io.ReadAll(resp.Body)
+ if string(body) != "OK" {
+ t.Errorf("got body %q; want %q", body, "OK")
+ }
+}
+
+func TestAPIHandler(t *testing.T) {
+ tests := []struct {
+ name string
+ method string
+ path string
+ body string
+ wantStatus int
+ wantBody string
+ }{
+ {
+ name: "get user",
+ method: http.MethodGet,
+ path: "/users/123",
+ wantStatus: http.StatusOK,
+ wantBody: `{"id":"123","name":"Alice"}`,
+ },
+ {
+ name: "not found",
+ method: http.MethodGet,
+ path: "/users/999",
+ wantStatus: http.StatusNotFound,
+ },
+ {
+ name: "create user",
+ method: http.MethodPost,
+ path: "/users",
+ body: `{"name":"Bob"}`,
+ wantStatus: http.StatusCreated,
+ },
+ }
+
+ handler := NewAPIHandler()
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ var body io.Reader
+ if tt.body != "" {
+ body = strings.NewReader(tt.body)
+ }
+
+ req := httptest.NewRequest(tt.method, tt.path, body)
+ req.Header.Set("Content-Type", "application/json")
+ w := httptest.NewRecorder()
+
+ handler.ServeHTTP(w, req)
+
+ if w.Code != tt.wantStatus {
+ t.Errorf("got status %d; want %d", w.Code, tt.wantStatus)
+ }
+
+ if tt.wantBody != "" && w.Body.String() != tt.wantBody {
+ t.Errorf("got body %q; want %q", w.Body.String(), tt.wantBody)
+ }
+ })
+ }
+}
+```
+
+## Test Komutları
+
+```bash
+# Tüm testleri çalıştır
+go test ./...
+
+# Verbose çıktı ile testleri çalıştır
+go test -v ./...
+
+# Belirli bir testi çalıştır
+go test -run TestAdd ./...
+
+# Pattern ile eşleşen testleri çalıştır
+go test -run "TestUser/Create" ./...
+
+# Race detector ile testleri çalıştır
+go test -race ./...
+
+# Coverage ile testleri çalıştır
+go test -cover -coverprofile=coverage.out ./...
+
+# Sadece kısa testleri çalıştır
+go test -short ./...
+
+# Timeout ile testleri çalıştır
+go test -timeout 30s ./...
+
+# Benchmark'ları çalıştır
+go test -bench=. -benchmem ./...
+
+# Fuzzing çalıştır
+go test -fuzz=FuzzParse -fuzztime=30s ./...
+
+# Test çalışma sayısı (flaky test tespiti için)
+go test -count=10 ./...
+```
+
+## En İyi Uygulamalar
+
+**YAPIN:**
+- Testleri ÖNCE yazın (TDD)
+- Kapsamlı coverage için table-driven testler kullanın
+- İmplementasyon değil davranış test edin
+- Helper fonksiyonlarda `t.Helper()` kullanın
+- Bağımsız testler için `t.Parallel()` kullanın
+- Kaynakları `t.Cleanup()` ile temizleyin
+- Senaryoyu açıklayan anlamlı test isimleri kullanın
+
+**YAPMAYIN:**
+- Private fonksiyonları doğrudan test etmeyin (public API üzerinden test edin)
+- Testlerde `time.Sleep()` kullanmayın (channel'lar veya condition'lar kullanın)
+- Flaky testleri göz ardı etmeyin (düzeltin veya kaldırın)
+- Her şeyi mocklamayın (mümkün olduğunda integration testlerini tercih edin)
+- Hata yolu testini atlamayın
+
+## CI/CD ile Entegrasyon
+
+```yaml
+# GitHub Actions örneği
+test:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: actions/setup-go@v5
+ with:
+ go-version: '1.22'
+
+ - name: Run tests
+ run: go test -race -coverprofile=coverage.out ./...
+
+ - name: Check coverage
+ run: |
+ go tool cover -func=coverage.out | grep total | awk '{print $3}' | \
+ awk -F'%' '{if ($1 < 80) exit 1}'
+```
+
+**Unutmayın**: Testler dokümantasyondur. Kodunuzun nasıl kullanılması gerektiğini gösterirler. Testleri açık yazın ve güncel tutun.
diff --git a/docs/tr/skills/jpa-patterns/SKILL.md b/docs/tr/skills/jpa-patterns/SKILL.md
new file mode 100644
index 00000000..ba5a1351
--- /dev/null
+++ b/docs/tr/skills/jpa-patterns/SKILL.md
@@ -0,0 +1,151 @@
+---
+name: jpa-patterns
+description: Spring Boot'ta entity tasarımı, ilişkiler, sorgu optimizasyonu, transaction'lar, auditing, indeksleme, sayfalama ve pooling için JPA/Hibernate kalıpları.
+origin: ECC
+---
+
+# JPA/Hibernate Kalıpları
+
+Spring Boot'ta veri modelleme, repository'ler ve performans ayarlaması için kullanın.
+
+## Ne Zaman Aktifleştirmeli
+
+- JPA entity'leri ve tablo eşlemelerini tasarlarken
+- İlişkileri tanımlarken (@OneToMany, @ManyToOne, @ManyToMany)
+- Sorguları optimize ederken (N+1 önleme, fetch stratejileri, projections)
+- Transaction'ları, auditing'i veya soft delete'leri yapılandırırken
+- Sayfalama, sıralama veya özel repository metodları kurarken
+- Connection pooling (HikariCP) veya second-level caching ayarlarken
+
+## Entity Tasarımı
+
+```java
+@Entity
+@Table(name = "markets", indexes = {
+ @Index(name = "idx_markets_slug", columnList = "slug", unique = true)
+})
+@EntityListeners(AuditingEntityListener.class)
+public class MarketEntity {
+ @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(nullable = false, length = 200)
+ private String name;
+
+ @Column(nullable = false, unique = true, length = 120)
+ private String slug;
+
+ @Enumerated(EnumType.STRING)
+ private MarketStatus status = MarketStatus.ACTIVE;
+
+ @CreatedDate private Instant createdAt;
+ @LastModifiedDate private Instant updatedAt;
+}
+```
+
+Auditing'i etkinleştir:
+```java
+@Configuration
+@EnableJpaAuditing
+class JpaConfig {}
+```
+
+## İlişkiler ve N+1 Önleme
+
+```java
+@OneToMany(mappedBy = "market", cascade = CascadeType.ALL, orphanRemoval = true)
+private List