@hd-agent-kit/cli 1.0.0

package/templates/.agents/skills/security-scan/SKILL.md

@@ -0,0 +1,319 @@
+# /security-scan — Güvenlik Tarama Skill'i
+
+> **Tetikleyici:** `/security-scan`
+> **Amaç:** Dependency audit, XSS/CSRF risk tespiti, env variable kontrolü ve güvenlik best practice'lerine uyum raporu oluşturmak.
+> **Çıktı:** Kategorize edilmiş güvenlik raporu + düzeltme önerileri
+
+---
+
+## Temel İlkeler
+
+- **Defense in depth.** Tek bir güvenlik katmanına güvenme; çok katmanlı savunma kur.
+- **Principle of least privilege.** Her modül/kullanıcı sadece gereken minimum yetkiye sahip olsun.
+- **Fail secure.** Hata durumunda güvenli tarafa düş (erişimi kapat, default deny).
+- **Input'a asla güvenme.** Tüm kullanıcı girdilerini her zaman doğrula ve sanitize et.
+
+---
+
+## Kullanım Formatları
+
+```
+/security-scan                              ← Tüm proje taraması
+/security-scan src/services/auth.ts         ← Belirli dosya taraması
+/security-scan dependencies                 ← Sadece dependency audit
+/security-scan env                          ← Sadece env variable kontrolü
+/security-scan auth                         ← Auth katmanı güvenlik kontrolü
+```
+
+---
+
+## Tarama Kategorileri
+
+### Kategori 1: Dependency Güvenliği
+
+```
+📦 Dependency Audit:
+
+1. Bilinen Güvenlik Açıkları:
+   ├── npm audit / pnpm audit sonucu:
+   │   ├── Critical: [N adet]
+   │   ├── High: [N adet]
+   │   ├── Moderate: [N adet]
+   │   └── Low: [N adet]
+   ├── Etkilenen paketler:
+   │   ├── [paket@versiyon] → [CVE-XXXX-XXXX] — [açıklama] — Fix: [güncel versiyon]
+   │   └── ...
+   └── Transitive dependency riskleri: [dolaylı bağımlılıklardaki açıklar]
+
+2. Eski/Bakımsız Dependency'ler:
+   ├── Son güncellemesi 1+ yıl: [liste]
+   ├── Deprecated paketler: [liste]
+   ├── Bilinen alternatifler: [mevcut → önerilen]
+   └── Önemsiz/gereksiz dependency'ler: [kaldırılabilecekler]
+
+3. License Kontrolü:
+   ├── Ticari kullanımda sorunlu lisanslar: [GPL, AGPL vs.]
+   ├── Lisans uyumsuzlukları: [var/yok]
+   └── Lisansı belirsiz paketler: [liste]
+
+4. Supply Chain Riskleri:
+   ├── Lockfile güncel mi? (package-lock.json / pnpm-lock.yaml)
+   ├── Exact versioning kullanılıyor mu?
+   ├── .npmrc güvenlik ayarları: [var/yok]
+   └── Typosquatting riski: [benzer isimli paketler]
+```
+
+### Kategori 2: XSS (Cross-Site Scripting) Taraması
+
+```
+🛡️ XSS Risk Analizi:
+
+1. dangerouslySetInnerHTML Kullanımı:
+   ├── Kullanım yerleri: [dosya:satır listesi]
+   ├── Sanitization: [DOMPurify kullanılıyor mu?]
+   ├── Kaynak güvenli mi: [kullanıcı girdisi mi, statik veri mi?]
+   └── Risk seviyesi: [Kritik/Yüksek/Orta/Düşük]
+
+2. URL İşleme:
+   ├── href'e kullanıcı girdisi aktarılıyor mu?
+   ├── javascript: protocol kontrolü: [var/yok]
+   ├── URL sanitization: [var/yok]
+   └── window.location manipülasyonu: [var/yok]
+
+3. DOM Manipülasyonu:
+   ├── innerHTML kullanımı: [var/yok]
+   ├── document.write kullanımı: [var/yok]
+   ├── eval() kullanımı: [var/yok]
+   ├── new Function() kullanımı: [var/yok]
+   └── template literal'da HTML: [var/yok]
+
+4. Üçüncü Parti Script'ler:
+   ├── Harici script tag'ları: [liste]
+   ├── SRI (Subresource Integrity): [var/yok]
+   ├── Sandbox attribute: [iframe'lerde var/yok]
+   └── Postmessage origin kontrolü: [var/yok]
+```
+
+### Kategori 3: CSRF & İstek Güvenliği
+
+```
+🔐 CSRF & Request Security:
+
+1. CSRF Koruması:
+   ├── CSRF token implementasyonu: [var/yok]
+   ├── SameSite cookie attribute: [var/yok, değeri]
+   ├── Custom header kontrolü: [var/yok]
+   └── State-changing GET request'ler: [var/yok — olmamalı]
+
+2. CORS Yapılandırması:
+   ├── Access-Control-Allow-Origin: [değer]
+   ├── Wildcard (*) kullanımı: [var/yok — riskli]
+   ├── Credentials ile CORS: [var/yok]
+   ├── Allowed methods: [liste]
+   └── Exposed headers: [liste]
+
+3. HTTP Güvenlik Header'ları:
+   ├── Content-Security-Policy: [var/yok, değer]
+   ├── X-Content-Type-Options: nosniff [var/yok]
+   ├── X-Frame-Options: [var/yok, değer]
+   ├── Strict-Transport-Security: [var/yok]
+   ├── Referrer-Policy: [var/yok, değer]
+   ├── Permissions-Policy: [var/yok]
+   └── X-XSS-Protection: [var/yok — modern tarayıcılarda gereksiz]
+```
+
+### Kategori 4: Authentication & Authorization
+
+```
+🔑 Auth Güvenliği:
+
+1. Token Yönetimi:
+   ├── Token storage: [localStorage / sessionStorage / httpOnly cookie]
+   ├── Token tipi: [JWT / opaque / session ID]
+   ├── Token expiry: [var/yok, süre]
+   ├── Refresh token mekanizması: [var/yok]
+   ├── Token rotation: [var/yok]
+   └── Logout'ta token invalidation: [var/yok]
+
+2. Oturum Güvenliği:
+   ├── Session fixation koruması: [var/yok]
+   ├── Concurrent session kontrolü: [var/yok]
+   ├── Idle timeout: [var/yok, süre]
+   ├── Absolute timeout: [var/yok, süre]
+   └── Secure/HttpOnly/SameSite cookie flags: [var/yok]
+
+3. Yetkilendirme:
+   ├── Route-level auth check: [var/yok]
+   ├── API-level auth check: [var/yok]
+   ├── Role-based access control: [var/yok]
+   ├── Client-side route guard: [var/yok]
+   ├── Server-side middleware: [var/yok]
+   └── Privilege escalation riski: [var/yok]
+
+4. Şifre/Credential Güvenliği:
+   ├── Şifre karmaşıklık kuralları: [var/yok]
+   ├── Rate limiting (brute force): [var/yok]
+   ├── Account lockout: [var/yok]
+   ├── Password hash algoritması: [bcrypt/argon2/scrypt]
+   └── 2FA desteği: [var/yok]
+```
+
+### Kategori 5: Environment & Secret Yönetimi
+
+```
+🔒 Environment & Secrets:
+
+1. Env Variable Güvenliği:
+   ├── Client-side'da erişilebilen secret'lar: [RISK — liste]
+   ├── .env dosyası gitignore'da mı?: [Evet/Hayır]
+   ├── .env.example mevcut mu?: [Evet/Hayır]
+   ├── Hardcoded secret/API key: [var/yok — dosya:satır]
+   └── Secret'lar sadece server-side'da mı?: [Evet/Hayır]
+
+2. Git Geçmişi:
+   ├── Geçmişte commit'lenmiş secret: [tespit edilebiliyorsa]
+   ├── .gitignore kapsamı yeterli mi?: [Evet/Hayır]
+   └── Git hook'lar (secret scanning): [var/yok]
+
+3. Üçüncü Parti Servis Key'leri:
+   ├── API key'ler rotation'a uygun mu?: [Evet/Hayır]
+   ├── Minimum yetki prensibi: [Evet/Hayır]
+   ├── Key scope/restriction: [var/yok]
+   └── Ayrı dev/prod key'ler: [Evet/Hayır]
+```
+
+### Kategori 6: Input Validation & Data Sanitization
+
+```
+🧹 Input Validation:
+
+1. Form Validation:
+   ├── Client-side validation: [var/yok, kütüphane]
+   ├── Server-side validation: [var/yok, kütüphane]
+   ├── Validation schema paylaşımı (client-server): [var/yok]
+   └── Zod/Yup/Valibot kullanımı: [var/yok]
+
+2. SQL/NoSQL Injection:
+   ├── Parameterized query kullanımı: [var/yok]
+   ├── ORM kullanımı: [var/yok — Prisma/Drizzle vs.]
+   ├── Raw query'ler: [var/yok — dosya:satır]
+   └── User input'un query'de doğrudan kullanımı: [var/yok]
+
+3. File Upload:
+   ├── File type validation: [var/yok]
+   ├── File size limiti: [var/yok, değer]
+   ├── File name sanitization: [var/yok]
+   ├── Magic number validation: [var/yok]
+   └── Upload dizini web root dışında mı?: [Evet/Hayır]
+
+4. API Input:
+   ├── Request body validation: [var/yok]
+   ├── Query parameter validation: [var/yok]
+   ├── Path parameter validation: [var/yok]
+   ├── Content-Type kontrolü: [var/yok]
+   └── Rate limiting: [var/yok]
+```
+
+### Kategori 7: Frontend-Specific Güvenlik
+
+```
+🖥️ Frontend Güvenlik:
+
+1. Dış Linkler:
+   ├── rel="noopener noreferrer" kullanımı: [var/yok]
+   ├── Target="_blank" güvenliği: [var/yok]
+   └── Outbound link kontrolü: [var/yok]
+
+2. Sensitive Data Handling:
+   ├── Console.log'da sensitive veri: [var/yok]
+   ├── localStorage'da sensitive veri: [var/yok]
+   ├── URL'de sensitive veri (query param): [var/yok]
+   ├── Error mesajlarında sensitive veri leak: [var/yok]
+   └── Source map production'da kapalı mı?: [Evet/Hayır]
+
+3. Content Injection:
+   ├── User-generated content sanitization: [var/yok]
+   ├── Markdown rendering güvenliği: [var/yok]
+   ├── Rich text editor güvenliği: [var/yok]
+   └── SVG upload XSS riski: [var/yok]
+```
+
+---
+
+## Puanlama Sistemi
+
+```
+🔒 Güvenlik Raporu:
+
+┌──────────────────────────┬───────┬──────────┐
+│ Kategori                 │ Puan  │ Seviye   │
+├──────────────────────────┼───────┼──────────┤
+│ Dependency Güvenliği     │ XX/100│ 🟢/🟡/🔴│
+│ XSS Koruması             │ XX/100│ 🟢/🟡/🔴│
+│ CSRF & Request Security  │ XX/100│ 🟢/🟡/🔴│
+│ Auth & Authorization     │ XX/100│ 🟢/🟡/🔴│
+│ Environment & Secrets    │ XX/100│ 🟢/🟡/🔴│
+│ Input Validation         │ XX/100│ 🟢/🟡/🔴│
+│ Frontend Security        │ XX/100│ 🟢/🟡/🔴│
+├──────────────────────────┼───────┼──────────┤
+│ GENEL                    │ XX/100│ 🟢/🟡/🔴│
+└──────────────────────────┴───────┴──────────┘
+
+🟢 90-100: Güvenli
+🟡 60-89: İyileştirme gerekli
+🔴 0-59: Kritik — acil müdahale
+```
+
+---
+
+## Düzeltme Önerileri
+
+```
+🎯 Düzeltme Planı (Öncelik Sırasına Göre):
+
+🔴 Kritik (Hemen Düzelt):
+1. [Sorun] → [Çözüm] — [Etkilenen dosya]
+2. [Sorun] → [Çözüm]
+
+🟡 Yüksek (Bu Sprint İçinde):
+3. [Sorun] → [Çözüm]
+4. [Sorun] → [Çözüm]
+
+🟢 Orta (Plana Al):
+5. [Sorun] → [Çözüm]
+6. [Sorun] → [Çözüm]
+
+ℹ️ Bilgi (Best Practice Önerisi):
+7. [Öneri]
+8. [Öneri]
+```
+
+---
+
+## OWASP Top 10 Kontrol Listesi
+
+Her taramada OWASP Top 10'u (2021) referans al:
+
+| # | Risk | Kontrol | Durum |
+|---|------|---------|-------|
+| A01 | Broken Access Control | Yetkilendirme kontrolleri | ✅/❌ |
+| A02 | Cryptographic Failures | Şifreleme/hashing uygulamaları | ✅/❌ |
+| A03 | Injection | SQL/NoSQL/OS/LDAP injection koruması | ✅/❌ |
+| A04 | Insecure Design | Güvenli tasarım pattern'ları | ✅/❌ |
+| A05 | Security Misconfiguration | Header'lar, CORS, default ayarlar | ✅/❌ |
+| A06 | Vulnerable Components | Dependency güvenliği | ✅/❌ |
+| A07 | Auth Failures | Kimlik doğrulama zafiyetleri | ✅/❌ |
+| A08 | Data Integrity Failures | Veri bütünlüğü kontrolleri | ✅/❌ |
+| A09 | Logging Failures | Güvenlik log'lama | ✅/❌ |
+| A10 | SSRF | Server-Side Request Forgery koruması | ✅/❌ |
+
+---
+
+## Çıktı Formatı
+
+1. **Genel skor** — Hızlı bakış güvenlik puanlama tablosu
+2. **Kritik bulgular** — Acil düzeltme gerektiren sorunlar (varsa ilk başta vurgula)
+3. **Kategori detayları** — Her kategori için kontrol listesi sonuçları
+4. **OWASP Top 10 uyum** — Hangi riskler karşılanmış, hangisi eksik
+5. **Düzeltme planı** — Öncelik sırasına göre aksiyon listesi
+6. **Otomatik düzeltilebilecekler** — Hemen uygulanabilecek fix'ler (kullanıcı onayı ile)

package/templates/.agents/skills/write-tests/SKILL.md

@@ -0,0 +1,389 @@
+# /write-tests — Test Yazma Skill'i
+
+> **Tetikleyici:** `/write-tests [dosya/modül]`
+> **Amaç:** Belirtilen component, hook veya utility için kapsamlı test dosyası üretmek.
+> **Çıktı:** Proje convention'ına uygun test dosyası
+
+---
+
+## Temel İlkeler
+
+- **Kullanıcı davranışını test et, implementation detail'leri değil.** Testing Library felsefesi.
+- **Her test bağımsız (isolated) olmalı.** Testler arası paylaşılan state olmamalı.
+- **Mock'ları minimum tut.** Gerçek modülleri mümkün olduğunca kullan.
+- **Test piramidini uygula.** Çok unit test, az integration test, minimal E2E test.
+- **Mevcut test convention'ına uy.** Proje kurallarındaki test yapısını takip et.
+
+---
+
+## Kullanım Formatları
+
+```
+/write-tests src/components/Button.tsx
+/write-tests src/hooks/useAuth.ts
+/write-tests src/utils/formatDate.ts
+/write-tests src/services/userService.ts
+/write-tests src/features/auth/           ← Tüm klasör için test planı
+/write-tests UserProfile                  ← Modül adı ile (AI dosyayı bulur)
+```
+
+---
+
+## Uygulama Adımları
+
+### Adım 1: Hedef Analizi
+
+Hedef dosyayı oku ve şunları tespit et:
+
+```
+📋 Test Hedefi Analizi:
+├── Hedef dosya: [dosya yolu]
+├── Dosya tipi: [component / hook / util / service / page]
+├── Export'lar: [fonksiyon/component listesi]
+├── Bağımlılıklar: [import edilen modüller]
+├── Props/Parametreler: [tip bilgileri]
+├── Side effect'ler: [API çağrısı, localStorage, timer vs.]
+├── Mevcut test: [var/yok, dosya yolu]
+└── Test runner: [Vitest / Jest / projeden tespit et]
+```
+
+### Adım 2: Proje Test Convention Tespiti
+
+Projede mevcut testleri inceleyerek convention belirle:
+
+```
+🔍 Test Convention:
+├── Test runner: [Vitest / Jest]
+├── Test dosya konumu: [yanında / __tests__/ klasöründe]
+├── Dosya adlandırma: [*.test.ts / *.spec.ts / *.test.tsx]
+├── Import stili: [import { render } from '@testing-library/react']
+├── Describe/it yapısı: [nested describe / flat it]
+├── Mock yaklaşımı: [vi.mock / jest.mock / MSW]
+├── Setup dosyası: [setupTests.ts / vitest.setup.ts]
+├── Custom render/wrapper: [var/yok — theme provider, router wrapper vs.]
+└── Assertion stili: [expect().toBe / expect().toEqual / custom matchers]
+```
+
+### Adım 3: Test Senaryoları Planlama
+
+Her dosya tipi için farklı senaryo stratejisi:
+
+#### Component Test Senaryoları
+```
+📝 Test Planı — [ComponentName]:
+
+1. Rendering Testleri:
+   □ Default props ile doğru render edilme
+   □ Tüm prop varyasyonları (her prop kombinasyonu)
+   □ Conditional rendering (if/ternary ile gösterilen/gizlenen bölümler)
+   □ Children prop ile render
+   □ Empty/null state render
+
+2. Kullanıcı Etkileşimi:
+   □ Click olayları (button, link, toggle)
+   □ Form input'ları (type, clear, submit)
+   □ Keyboard navigasyonu (Tab, Enter, Escape)
+   □ Hover/focus state'leri (tooltip, dropdown)
+
+3. State Değişiklikleri:
+   □ Initial state doğruluğu
+   □ State geçişleri (loading → success, loading → error)
+   □ Controlled vs uncontrolled davranış
+
+4. API/Async Operasyonlar:
+   □ Loading state gösterimi
+   □ Success state ve veri gösterimi
+   □ Error state ve hata mesajı
+   □ Retry mekanizması (varsa)
+
+5. Edge Case'ler:
+   □ Boş veri / undefined prop
+   □ Çok uzun metin / overflow
+   □ Hızlı ardışık tıklama (debounce/throttle)
+   □ Unmount sırasında cleanup
+
+6. Erişilebilirlik:
+   □ ARIA attribute'ları doğru mu?
+   □ Semantik HTML kullanılmış mı?
+   □ Keyboard ile erişilebilir mi?
+   □ Screen reader uyumlu mu?
+```
+
+#### Hook Test Senaryoları
+```
+📝 Test Planı — [useHookName]:
+
+1. Initial State:
+   □ Default değerler doğru mu?
+   □ Parametrelerle başlatma
+
+2. State Güncellemeleri:
+   □ Her action/setter doğru çalışıyor mu?
+   □ State geçişleri beklenen sırada mı?
+   □ Birden fazla güncelleme batch ediliyor mu?
+
+3. Side Effect'ler:
+   □ useEffect doğru zamanda çalışıyor mu?
+   □ Cleanup fonksiyonu çağrılıyor mu?
+   □ Dependency değişikliğinde yeniden çalışıyor mu?
+
+4. API Entegrasyonu (varsa):
+   □ Fetch başarılı senaryo
+   □ Fetch hata senaryosu
+   □ Loading/stale/error state geçişleri
+   □ Cache invalidation (TanStack Query vs.)
+
+5. Edge Case'ler:
+   □ Rapid state güncellemeleri
+   □ Unmount sırasında async işlem
+   □ Invalid parametre geçilmesi
+```
+
+#### Utility/Service Test Senaryoları
+```
+📝 Test Planı — [functionName]:
+
+1. Happy Path:
+   □ Normal input → beklenen output
+   □ Farklı geçerli input varyasyonları
+
+2. Edge Case'ler:
+   □ Boş input (null, undefined, empty string, empty array)
+   □ Sınır değerler (0, -1, MAX_SAFE_INTEGER)
+   □ Özel karakterler / unicode
+   □ Çok büyük input
+
+3. Error Handling:
+   □ Invalid input → doğru hata fırlatma
+   □ Hata mesajı açıklayıcı mı?
+
+4. Type Safety (TypeScript):
+   □ Tip uyumsuzluğu compile-time'da yakalanıyor mu?
+   □ Return tipi doğru çıkarılıyor mu?
+```
+
+### Adım 4: Test Dosyası Oluşturma
+
+Test planını onaylandıktan sonra, proje convention'ına uygun test dosyası yaz:
+
+```
+📄 Test Dosyası Yapısı:
+
+[dosya-adı].test.tsx (veya projede kullanılan uzantı)
+├── Import'lar (test utility, component, mock'lar)
+├── Mock tanımları (gerekirse)
+├── describe('[ComponentName]', () => {
+│   ├── describe('Rendering', () => { ... })
+│   ├── describe('User Interaction', () => { ... })
+│   ├── describe('State Changes', () => { ... })
+│   ├── describe('API/Async', () => { ... })
+│   ├── describe('Edge Cases', () => { ... })
+│   └── describe('Accessibility', () => { ... })
+│   })
+└── Helper fonksiyonlar (renderWithProviders vs.)
+```
+
+---
+
+## Test Yazım Kuralları
+
+### Element Seçim Önceliği (Testing Library)
+
+```
+1. getByRole        → En çok tercih edilen (erişilebilirlik dostu)
+2. getByLabelText   → Form elemanları için
+3. getByPlaceholderText → Input'lar için (label yoksa)
+4. getByText        → Görünür metin ile seçim
+5. getByDisplayValue → Form değeri ile seçim
+6. getByAltText     → Görseller için
+7. getByTitle       → title attribute ile
+8. getByTestId      → SON ÇARE — sadece diğerleri işe yaramadığında
+```
+
+### Async Test Kuralları
+
+```typescript
+// ✅ Doğru — waitFor ile async bekleme
+await waitFor(() => {
+  expect(screen.getByText('Loaded')).toBeInTheDocument();
+});
+
+// ✅ Doğru — findBy kullanımı (waitFor + getBy kısaltması)
+const element = await screen.findByText('Loaded');
+
+// ❌ Yanlış — setTimeout ile bekleme
+await new Promise(resolve => setTimeout(resolve, 1000));
+```
+
+### Mock Kuralları
+
+```typescript
+// ✅ Doğru — Minimal mock, sadece gerekli kısım
+vi.mock('@/services/api', () => ({
+  fetchUser: vi.fn(),
+}));
+
+// ✅ Doğru — MSW ile API mock (integration test)
+server.use(
+  http.get('/api/users/:id', () => {
+    return HttpResponse.json({ id: 1, name: 'Test User' });
+  })
+);
+
+// ❌ Yanlış — Tüm modülü mock'lama (gereksiz)
+vi.mock('@/services/api'); // Auto-mock tüm export'ları undefined yapar
+```
+
+### Assertion Best Practice'leri
+
+```typescript
+// ✅ Spesifik assertion
+expect(screen.getByRole('button', { name: 'Submit' })).toBeEnabled();
+expect(screen.getByRole('alert')).toHaveTextContent('Error occurred');
+
+// ❌ Genel assertion (ne test ettiği belirsiz)
+expect(container.innerHTML).toContain('Submit');
+expect(document.querySelector('.error')).toBeTruthy();
+```
+
+---
+
+## Dosya Tipi Bazlı Test Şablonları
+
+### Component Test Şablonu
+
+```typescript
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi } from 'vitest'; // veya jest'ten
+import { ComponentName } from './ComponentName';
+
+// Gerekirse wrapper
+function renderComponent(props = {}) {
+  const defaultProps = {
+    // default prop değerleri
+  };
+  return render(<ComponentName {...defaultProps} {...props} />);
+}
+
+describe('ComponentName', () => {
+  describe('Rendering', () => {
+    it('should render with default props', () => {
+      renderComponent();
+      expect(screen.getByRole('...')).toBeInTheDocument();
+    });
+  });
+
+  describe('User Interaction', () => {
+    it('should handle click event', async () => {
+      const user = userEvent.setup();
+      const handleClick = vi.fn();
+      renderComponent({ onClick: handleClick });
+
+      await user.click(screen.getByRole('button'));
+      expect(handleClick).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle empty data gracefully', () => {
+      renderComponent({ data: [] });
+      expect(screen.getByText('No items')).toBeInTheDocument();
+    });
+  });
+});
+```
+
+### Hook Test Şablonu
+
+```typescript
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi } from 'vitest';
+import { useHookName } from './useHookName';
+
+describe('useHookName', () => {
+  it('should return initial state', () => {
+    const { result } = renderHook(() => useHookName());
+    expect(result.current.value).toBe(initialValue);
+  });
+
+  it('should update state', () => {
+    const { result } = renderHook(() => useHookName());
+    act(() => {
+      result.current.setValue('new value');
+    });
+    expect(result.current.value).toBe('new value');
+  });
+
+  it('should handle async operation', async () => {
+    const { result } = renderHook(() => useHookName());
+    act(() => {
+      result.current.fetchData();
+    });
+    await waitFor(() => {
+      expect(result.current.data).toBeDefined();
+    });
+  });
+});
+```
+
+### Utility Test Şablonu
+
+```typescript
+import { describe, it, expect } from 'vitest';
+import { functionName } from './functionName';
+
+describe('functionName', () => {
+  describe('happy path', () => {
+    it.each([
+      ['input1', 'expected1'],
+      ['input2', 'expected2'],
+    ])('should return %s for input %s', (input, expected) => {
+      expect(functionName(input)).toBe(expected);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle null input', () => {
+      expect(functionName(null)).toBe(defaultValue);
+    });
+
+    it('should handle empty string', () => {
+      expect(functionName('')).toBe(defaultValue);
+    });
+  });
+
+  describe('error cases', () => {
+    it('should throw for invalid input', () => {
+      expect(() => functionName(invalidInput)).toThrow('Expected error message');
+    });
+  });
+});
+```
+
+---
+
+## Test Coverage Hedefleri
+
+```
+Önerilen Minimum Coverage:
+├── Statements: %80+
+├── Branches: %75+
+├── Functions: %80+
+└── Lines: %80+
+
+Kritik Modüller İçin (auth, payment, data):
+├── Statements: %95+
+├── Branches: %90+
+├── Functions: %95+
+└── Lines: %95+
+```
+
+---
+
+## Çıktı Formatı
+
+1. **Test planı özeti** — Hangi senaryolar test edilecek
+2. **Kullanıcı onayı** — Plan uygun mu, ekleme/çıkarma var mı?
+3. **Test dosyası** — Convention'a uygun, çalıştırılabilir test kodu
+4. **Çalıştırma komutu** — `npx vitest run [dosya]` veya benzeri