---
name: design-pattern-enhancer
description: >
  Design pattern notlarını (ham web clip veya basit notlar) kapsamlı, 
  yapılandırılmış ve NotebookLM-uyumlu Obsidian notlarına dönüştürür.
  Tetikleyiciler: "pattern notunu zenginleştir", "enhance-pattern", 
  "design pattern belgesi oluştur", "pattern'ı template'e dönüştür",
  ham bir design pattern notu verildiğinde ve genişletme istendiğinde.
  Her zaman C++ kod örnekleri, image prompt'ları ve Q&A bölümü içerir.
---

# Design Pattern Enhancer Skill

Bu skill, ham veya kısa design pattern notlarını standart template 
kullanarak kapsamlı Obsidian belgelerine dönüştürür.

## Tetiklenme Koşulları

- Kullanıcı bir design pattern notu yapıştırır + "zenginleştir/enhance/genişlet" der
- `/enhance-pattern` komutu çalıştırılır
- "Bu pattern için kapsamlı not oluştur" gibi bir istek gelir
- Şu pattern isimlerinden herhangi biri + "belge/not/döküman" birlikte geçer:
  Singleton, Factory, Builder, Prototype, Abstract Factory,
  Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy,
  Chain of Responsibility, Command, Iterator, Mediator, Memento,
  Observer, State, Strategy, Template Method, Visitor

## Süreç

### 0. Kaynağı Oku (Otomatik)

Kullanıcıdan içerik yapıştırması **bekleme**. Argümana göre dosyayı oku:

- `/enhance-pattern Observer` → `Clippings/Observer.md` oku
- `/enhance-pattern @Clippings/Command.md` → o yolu oku
- Argüman yoksa → `Clippings/` dizinini listele, kullanıcıya hangi pattern'ı istediğini sor
- Dosya okundu mu? → Doğrudan Adım 1'e geç, kullanıcıdan ek girdi isteme
- Çıktıyı ekrana yazdırma → `patterns/<type>/<PatternName>.md` yoluna **Write** ile kaydet
- Kayıt tamamlandıktan sonra `Design Patterns Index.md` içinde pattern satırındaki `🔲` işaretini `✅` yap

### 1. Ham İçerik Analizi

Girilen ham nottan çıkar:
- Pattern adı → frontmatter `title`
- Kategori (creational/structural/behavioral) → `pattern_type`
- Zorluk tahmini → `difficulty`
- Mevcut açıklamalar → temel referans
- Pseudocode varsa → C++ implementasyon için referans
- İlgili pattern listesi → `related_patterns`

### 2. İçerik Üretimi Standartları

#### Dil Kuralları
- Açıklamalar: **Türkçe**
- Kod, teknik terim, pattern isimleri: **İngilizce**
- Kod yorumları: **İngilizce** (evrensel okunabilirlik için)
- Q&A soruları: **Türkçe**, cevaplar: **Türkçe** (teknik terimler İngilizce kalır)

#### C++ Standartları
```
Standard : C++17 minimum, C++20 tercih edilir
Pointers : std::unique_ptr, std::shared_ptr (raw pointer kullanma)
Polymorphism: Pure virtual functions + override keyword
RAII     : Kaynak yönetimi constructor/destructor ile
Output   : std::cout ile görünür çıktı ver
Comments : Her sınıf için amaç yorumu, kritik satırlar için satır yorumu
Structure: Bildirimler → `.h` (interface + class decl.), Tanımlar → `.cpp` (impl. + main())
```

#### C++ Örnek Şablonu (Temel)
```cpp
/**
 * Design Pattern: [Pattern Name]
 * Category: [Creational/Structural/Behavioral]  
 * Intent: [Tek cümle]
 * C++17 Implementation
 */
#include <iostream>
#include <memory>
#include <string>
#include <vector>

// ─────────────────────────────────────────
// ABSTRACT INTERFACE
// ─────────────────────────────────────────
class IComponent {
public:
    virtual ~IComponent() = default;
    virtual void operation() = 0;
};

// ─────────────────────────────────────────
// CONCRETE IMPLEMENTATIONS  
// ─────────────────────────────────────────
class ConcreteA : public IComponent {
public:
    void operation() override {
        std::cout << "ConcreteA::operation()\n";
    }
};

// ─────────────────────────────────────────
// CONTEXT / CLIENT
// ─────────────────────────────────────────
class Context {
    std::unique_ptr<IComponent> component_;
public:
    explicit Context(std::unique_ptr<IComponent> c) 
        : component_(std::move(c)) {}
    
    void doWork() { component_->operation(); }
};

// ─────────────────────────────────────────
// USAGE
// ─────────────────────────────────────────
int main() {
    auto ctx = Context(std::make_unique<ConcreteA>());
    ctx.doWork();
    return 0;
}
```

#### Mermaid Diyagram Standartları

**KURAL: ASCII diyagram hiçbir yerde kullanılmaz. Her diyagram Mermaid formatında olmalıdır.**

Her pattern notu şu diyagramları içermeli:

| Diyagram | Mermaid Tipi | Zorunluluk |
|----------|-------------|------------|
| Sınıf yapısı | `classDiagram` | Zorunlu — her pattern |
| Runtime akış | `sequenceDiagram` | Zorunlu — her pattern |
| Durum makinesi | `stateDiagram-v2` | State, Observer, Command vb. |
| Karar/akış | `flowchart TD` | Factory, Builder, Chain of Responsibility vb. |

##### classDiagram Şablonu

```mermaid
classDiagram
    class Context {
        -state: IState
        +setState(state: IState) void
        +request() void
    }
    class IState {
        <<interface>>
        +handle(context: Context) void
    }
    class ConcreteStateA {
        -data: string
        +handle(context: Context) void
    }
    class ConcreteStateB {
        +handle(context: Context) void
    }
    Context "1" --> "1" IState : delegates
    IState <|.. ConcreteStateA : implements
    IState <|.. ConcreteStateB : implements
```

##### sequenceDiagram Şablonu

```mermaid
sequenceDiagram
    participant Client
    participant Context
    participant ConcreteState

    Client->>+Context: request()
    activate Context
    Context->>+ConcreteState: handle(context)
    Note right of ConcreteState: İş mantığı burada çalışır
    ConcreteState->>Context: setState(newState)
    ConcreteState-->>-Context: done
    deactivate Context
    Context-->>Client: response
```

##### stateDiagram-v2 Şablonu (State/Observer için)

```mermaid
stateDiagram-v2
    direction LR
    [*] --> StateA : initial

    StateA --> StateB : eventA
    StateB --> StateA : eventB
    StateB --> StateC : eventC
    StateC --> [*] : terminal

    StateA : StateA\nentry: onEnter()\nexit: onExit()
    StateB : StateB\ndo: doWork()
```

##### flowchart TD Şablonu (Factory/Builder/Chain için)

```mermaid
flowchart TD
    Client([Client]) -->|"createProduct(type)"| Factory

    Factory{Factory\nswitch type}
    Factory -->|type == A| ConcreteA[ConcreteProductA]
    Factory -->|type == B| ConcreteB[ConcreteProductB]
    Factory -->|unknown| Error[throw exception]

    ConcreteA --> Result([IProduct])
    ConcreteB --> Result
```

##### Mermaid Sözdizimi Hızlı Referans

```
classDiagram ilişki sembolleri:
  <|--   Inheritance (kalıtım / extends)
  <|..   Realization (interface impl.)
  *--    Composition (kompozisyon, sahiplik)
  o--    Aggregation (agregasyon, zayıf sahiplik)
  -->    Association / Dependency (bağımlılık)
  ..>    Dependency dashed (geçici bağımlılık)

Stereotipler:    <<interface>>
  <<abstract>>
  <<singleton>>
  <<factory>>

Visibility:
  + public
  - private
  # protected
  ~ package/internal

Kardinalite: "1", "*", "0..1", "1..*"  (tırnak içinde)
```

#### Python Örnek Şablonu (3.10+)

```python
"""
Design Pattern: [Pattern Name]
Category: [Creational/Structural/Behavioral]
Intent: [Tek cümle]
Python 3.10+ Implementation
"""
from abc import ABC, abstractmethod
from typing import Optional

# ─────────────────────────────────────────
# ABSTRACT BASE CLASS
# ─────────────────────────────────────────
class IComponent(ABC):
    """Abstract contract for all concrete components."""

    @abstractmethod
    def operation(self) -> str:
        pass

# ─────────────────────────────────────────
# CONCRETE IMPLEMENTATIONS
# ─────────────────────────────────────────
class ConcreteA(IComponent):
    def operation(self) -> str:
        return "ConcreteA.operation()"

# ─────────────────────────────────────────
# CONTEXT / CLIENT
# ─────────────────────────────────────────
class Context:
    def __init__(self, component: IComponent) -> None:
        self._component = component

    def do_work(self) -> None:
        print(self._component.operation())

# ─────────────────────────────────────────
# USAGE
# ─────────────────────────────────────────
if __name__ == "__main__":
    ctx = Context(ConcreteA())
    ctx.do_work()
```

#### Go Örnek Şablonu (1.21+)

```go
// Design Pattern: [Pattern Name]
// Category: [Creational/Structural/Behavioral]
// Intent: [Tek cümle]
// Go 1.21+ Implementation
package main

import "fmt"

// ─────────────────────────────────────────
// INTERFACE
// ─────────────────────────────────────────

// IComponent defines the contract for all concrete components.
type IComponent interface {
	Operation() string
}

// ─────────────────────────────────────────
// CONCRETE IMPLEMENTATIONS
// ─────────────────────────────────────────

type ConcreteA struct{}

func (c *ConcreteA) Operation() string {
	return "ConcreteA.Operation()"
}

// ─────────────────────────────────────────
// CONTEXT / CLIENT
// ─────────────────────────────────────────

type Context struct {
	component IComponent
}

func NewContext(c IComponent) *Context {
	return &Context{component: c}
}

func (ctx *Context) DoWork() {
	fmt.Println(ctx.component.Operation())
}

// ─────────────────────────────────────────
// USAGE
// ─────────────────────────────────────────

func main() {
	ctx := NewContext(&ConcreteA{})
	ctx.DoWork()
}
```

#### Dil Karşılaştırması — Pattern Kavramları

| Kavram | C++ | Python | Go |
|--------|-----|--------|----|
| Arayüz | `abstract class` + pure virtual | `ABC` + `@abstractmethod` | `interface` (implicit) |
| Kalıtım | `class B : public A` | `class B(A)` | Embedding (`B struct { A }`) |
| Smart pointer | `unique_ptr<T>` | Otomatik GC | GC (pointer `*T`) |
| Thread safety | `std::mutex` | `threading.Lock` / GIL | `sync.Mutex` / channel |
| Test | Google Test | pytest | `testing` package |

#### Image Prompt Formatı

**Mimari diyagram için:**
```
[Pattern Name] design pattern architecture diagram, isometric technical illustration, 
[component1] connected to [component2] via arrows, 
soft blue and white color palette, modern flat design, 
geometric shapes, professional software documentation style, 
no text labels, clean vector art, --ar 16:9 --v 6 --style raw
```

**Gerçek dünya analojisi için:**
```
[Analogy object/scene], symbolic representation of [pattern concept],
minimalist flat illustration, [dominant color] accent,
professional infographic aesthetic, clean background,
metaphorical visualization, no text, --ar 1:1 --v 6
```

#### Q&A Bloom Taxonomy Dağılımı (minimum 10 soru)

| Seviye | Soru sayısı | Örnek fiiller |
|--------|-------------|---------------|
| Hatırla | 2 | tanımla, listele, adlandır |
| Anla | 2 | açıkla, özetle, yorumla |
| Uygula | 2 | göster, kullan, çöz |
| Analiz et | 2 | karşılaştır, ayırt et, incele |
| Değerlendir | 1 | savun, eleştir, seç |
| Yarat | 1 | tasarla, oluştur, geliştir |

### 3. Template Bölüm Üretim Kılavuzu

#### Frontmatter
- `difficulty`: Bileşen sayısı ve soyutlama derinliğine göre belirle
  - beginner: 2-3 bileşen, basit delegation
  - intermediate: 3-5 bileşen, state/context ilişkisi
  - advanced: 5+ bileşen, recursive composition, thread safety

#### Intent
Ham notta 1-2 cümle varsa → 4-5 cümleye genişlet:
- Cümle 1: Ne yapar (tanım)
- Cümle 2: Hangi problemi çözer
- Cümle 3: Ne zaman kullanılır
- Cümle 4: Ne sağlar (benefit)
- Cümle 5 (opsiyonel): Hangi prensipleri uygular

#### Problem Bölümü Derinleştirme
Ham notun problem açıklamasını şu formatla genişlet:
1. Soyut problem tanımı (1 paragraf)
2. Somut yazılım senaryosu (1 paragraf)
3. Kötü yaklaşım kodu (C++ anti-pattern)
4. Neden sürdürülemez olduğunun açıklaması

#### Analoji Üretimi
- Ham nottaki analogiyi **kullanma** (özgün üret veya kökten farklılaştır)
- Türkiye veya evrensel günlük hayat örneği seç
- 3 katmanlı anlat: Durum → Sorun → Pattern'ın analogu

#### Related Patterns Tablosu
Her ilişki için şablonu doldur:
- `[[Strategy]]` — Benzer yapı ama [temel fark]
- `[[Observer]]` — Genellikle [birlikte/alternatif kullanılır] çünkü [neden]

### 4. Çıktı Kalite Kontrol Listesi

Göndermeden önce her maddeyi işaretle:

- [ ] Tüm `{{...}}` placeholder'ları dolduruldu
- [ ] `[Image Prompt]` etiketleri gerçek prompt ile değiştirildi
- [ ] `[CPP Code]` etiketleri çalışan kod ile değiştirildi
- [ ] `[QA]` etiketi gerçek Q&A ile değiştirildi
- [ ] `[Analogy]` etiketi gerçek analoji ile değiştirildi
- [ ] İki ayrı C++ kod örneği var (temel + gelişmiş)
- [ ] İki ayrı image prompt var (diyagram + analoji)
- [ ] Q&A bölümünde ≥10 soru-cevap çifti var
- [ ] Obsidian `[[wikilink]]` formatı kullanıldı
- [ ] Mermaid `classDiagram` tüm sınıf/field/metod/ilişki/kardinalite ile dolduruldu
- [ ] Mermaid `sequenceDiagram` runtime akışı activate/deactivate ile gösteriyor
- [ ] Pattern türüne özgü ek Mermaid diyagramlar eklendi (gerekiyorsa)
- [ ] Hiç ASCII diyagram kullanılmadı
- [ ] C++ temel implementasyon `.h` (bildirimler) ve `.cpp` (tanımlar) olarak ayrılmış mı?
- [ ] Python implementasyonu ABC + type hints ile yazılmış mı?
- [ ] Go implementasyonu interface + struct pattern ile yazılmış mı?
- [ ] Her dil için (C++/Python/Go) thread safety notu eklenmiş mi?
- [ ] Her dil için test örneği (Google Test / pytest / testing) var mı?
- [ ] SOLID uyumu tablosu doldurulmuş mu?
- [ ] Framework & Standart Kütüphane Örnekleri tablosu doldurulmuş mu?
- [ ] Test stratejisi ve örnek test kodu var mı?
- [ ] Pros/Cons tablosu dolu
- [ ] Related Patterns tablosu dolu

### 5. Dosya Adı ve Konum Önerisi

```
Dosya adı: {PatternName}.md
            (boşluk yok, CamelCase veya kebab-case)

Konum:
  patterns/creational/   → Singleton, Factory, Builder, Prototype, Abstract Factory
  patterns/structural/   → Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy  
  patterns/behavioral/   → Chain, Command, Iterator, Mediator, Memento, 
                           Observer, State, Strategy, TemplateMethod, Visitor
```

## Hızlı Referans: Pattern Kategorileri

```
CREATIONAL  — Nesne yaratma mekanizmaları
STRUCTURAL  — Sınıf ve nesne kompozisyonu
BEHAVIORAL  — Algoritmalar ve sorumluluk dağılımı
```

## Bağlam Dosyaları

Bu skill çalışırken şu dosyaları referans al (varsa):
- `.claude/CLAUDE.md` — Proje genel bağlamı
- `templates/design-pattern-template.md` — Ana template
- İşlenen diğer pattern notları — Tutarlılık için

## Notlar

- Çıktı uzunluğu: Minimum 2000, ideal 2500-3500 kelime
- Ham not ne kadar kısa olursa olsun, çıktı her zaman tam template'i karşılamalı
- NotebookLM uyumluluğu için başlıklar net ve tutarlı olmalı
- Hiçbir section boş bırakılmamalı