feat: umbrella anchors with GoF sub-patterns

docs/anchors/gof-abstract-factory-pattern.adoc

@@ -0,0 +1,32 @@
+= GoF-Abstract Factory Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 2
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, creational, abstract factory, family, platform independence
+
+[%collapsible]
+====
+Full Name:: GoF Abstract Factory Pattern (Creational)
+
+Also known as:: Kit
+
+[discrete]
+== *Intent*:
+Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
+
+[discrete]
+== *When to Use*:
+* When a system should be independent of how its products are created
+* When a system should be configured with one of multiple families of products
+* When related product objects are designed to be used together and you need to enforce this constraint
+
+[discrete]
+== *Prompt Example*:
+"Erstelle eine Abstract Factory nach GoF, die UI-Komponenten für verschiedene Plattformen (Web, Mobile, Desktop) erzeugt, ohne dass der Client die konkreten Klassen kennen muss."
+
+[discrete]
+== *Related Anchors*:
+* <<gof-design-patterns,GoF Design Patterns>> (Umbrella)
+====

docs/anchors/gof-adapter-pattern.adoc

@@ -0,0 +1,31 @@
+= GoF-Adapter Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 1
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, structural, adapter, wrapper, interface conversion, compatibility
+
+[%collapsible]
+====
+Full Name:: GoF Adapter Pattern (Structural)
+
+Also known as:: Wrapper
+
+[discrete]
+== *Intent*:
+Convert the interface of a class into another interface clients expect.
+
+[discrete]
+== *When to Use*:
+* When you want to use an existing class whose interface doesn't match what you need
+* When you want to create a reusable class that cooperates with unrelated classes
+
+[discrete]
+== *Prompt Example*:
+"Erstelle einen Adapter nach GoF, der die Legacy-API auf unser neues Interface mappt, ohne den bestehenden Code zu ändern."
+
+[discrete]
+== *Related Anchors*:
+* <<gof-design-patterns,GoF Design Patterns>> (Umbrella)
+====

docs/anchors/gof-bridge-pattern.adoc

@@ -0,0 +1,30 @@
+= GoF-Bridge Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 2
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, structural, bridge, abstraction, implementation, decoupling
+
+[%collapsible]
+====
+Full Name:: GoF Bridge Pattern (Structural)
+
+[discrete]
+== *Intent*:
+Decouple an abstraction from its implementation so that the two can vary independently.
+
+[discrete]
+== *When to Use*:
+* When you want to avoid a permanent binding between an abstraction and its implementation
+* When both the abstractions and their implementations should be extensible by subclassing
+* When changes in the implementation should have no impact on clients
+
+[discrete]
+== *Prompt Example*:
+"Trenne die Rendering-Abstraktion von der plattformspezifischen Implementierung nach dem GoF-Bridge Pattern, damit beide unabhängig erweitert werden können."
+
+[discrete]
+== *Related Anchors*:
+* <<gof-design-patterns,GoF Design Patterns>> (Umbrella)
+====

docs/anchors/gof-builder-pattern.adoc

@@ -0,0 +1,29 @@
+= GoF-Builder Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 1
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, creational, builder, construction, fluent interface, complex objects
+
+[%collapsible]
+====
+Full Name:: GoF Builder Pattern (Creational)
+
+[discrete]
+== *Intent*:
+Separate the construction of a complex object from its representation so that the same construction process can create different representations.
+
+[discrete]
+== *When to Use*:
+* When the algorithm for creating a complex object should be independent of the parts and how they are assembled
+* When the construction process must allow different representations
+
+[discrete]
+== *Prompt Example*:
+"Implementiere einen Builder nach GoF für das QueryObject, mit Fluent API für Filter, Sortierung und Pagination."
+
+[discrete]
+== *Related Anchors*:
+* <<gof-design-patterns,GoF Design Patterns>> (Umbrella)
+====

docs/anchors/gof-chain-of-responsibility-pattern.adoc

@@ -0,0 +1,30 @@
+= GoF-Chain of Responsibility Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 2
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, behavioral, chain of responsibility, handler, pipeline, middleware
+
+[%collapsible]
+====
+Full Name:: GoF Chain of Responsibility Pattern (Behavioral)
+
+[discrete]
+== *Intent*:
+Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain.
+
+[discrete]
+== *When to Use*:
+* When more than one object may handle a request, and the handler isn't known a priori
+* When you want to issue a request to one of several objects without specifying the receiver explicitly
+* When the set of objects that can handle a request should be specified dynamically
+
+[discrete]
+== *Prompt Example*:
+"Implementiere eine Middleware-Pipeline nach dem GoF-Chain of Responsibility Pattern, bei der jeder Handler die Anfrage entweder verarbeitet oder an den nächsten weitergibt."
+
+[discrete]
+== *Related Anchors*:
+* <<gof-design-patterns,GoF Design Patterns>> (Umbrella)
+====

docs/anchors/gof-command-pattern.adoc

@@ -0,0 +1,30 @@
+= GoF-Command Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 1
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, behavioral, command, undo, queue, encapsulation, action
+
+[%collapsible]
+====
+Full Name:: GoF Command Pattern (Behavioral)
+
+[discrete]
+== *Intent*:
+Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.
+
+[discrete]
+== *When to Use*:
+* When you want to parameterize objects with an action to perform
+* When you need undo/redo functionality
+* When you need to queue, log, or schedule requests
+
+[discrete]
+== *Prompt Example*:
+"Implementiere ein Undo/Redo-System nach dem GoF-Command Pattern, bei dem jede Benutzeraktion als Command-Objekt gekapselt wird."
+
+[discrete]
+== *Related Anchors*:
+* <<gof-design-patterns,GoF Design Patterns>> (Umbrella)
+====

docs/anchors/gof-composite-pattern.adoc

@@ -0,0 +1,29 @@
+= GoF-Composite Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 2
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, structural, composite, tree, hierarchy, part-whole
+
+[%collapsible]
+====
+Full Name:: GoF Composite Pattern (Structural)
+
+[discrete]
+== *Intent*:
+Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions uniformly.
+
+[discrete]
+== *When to Use*:
+* When you want to represent part-whole hierarchies of objects
+* When you want clients to be able to ignore the difference between compositions of objects and individual objects
+
+[discrete]
+== *Prompt Example*:
+"Modelliere das Dateisystem nach dem GoF-Composite Pattern, sodass Dateien und Ordner einheitlich behandelt werden können."
+
+[discrete]
+== *Related Anchors*:
+* <<gof-design-patterns,GoF Design Patterns>> (Umbrella)
+====

docs/anchors/gof-decorator-pattern.adoc

@@ -0,0 +1,31 @@
+= GoF-Decorator Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 1
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, structural, decorator, wrapper, dynamic behavior, composition
+
+[%collapsible]
+====
+Full Name:: GoF Decorator Pattern (Structural)
+
+Also known as:: Wrapper
+
+[discrete]
+== *Intent*:
+Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing.
+
+[discrete]
+== *When to Use*:
+* To add responsibilities to objects dynamically and transparently
+* When extension by subclassing is impractical
+
+[discrete]
+== *Prompt Example*:
+"Verwende das GoF-Decorator Pattern, um dem Logger dynamisch Formatierung, Timestamp und Filterung hinzuzufügen."
+
+[discrete]
+== *Related Anchors*:
+* <<gof-design-patterns,GoF Design Patterns>> (Umbrella)
+====

docs/anchors/gof-design-patterns.adoc

@@ -4,6 +4,7 @@
 :proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
 :related: solid-principles, fowler-patterns, clean-architecture
 :tags: design-patterns, gang-of-four, oop, creational, structural, behavioral
+:sub-anchors: gof-strategy-pattern, gof-observer-pattern, gof-factory-method-pattern, gof-singleton-pattern, gof-adapter-pattern, gof-decorator-pattern, gof-command-pattern, gof-facade-pattern, gof-template-method-pattern, gof-builder-pattern, gof-state-pattern, gof-proxy-pattern, gof-abstract-factory-pattern, gof-composite-pattern, gof-iterator-pattern, gof-mediator-pattern, gof-chain-of-responsibility-pattern, gof-bridge-pattern, gof-prototype-pattern, gof-flyweight-pattern, gof-interpreter-pattern, gof-memento-pattern, gof-visitor-pattern
 
 [%collapsible]
 ====

docs/anchors/gof-facade-pattern.adoc

@@ -0,0 +1,29 @@
+= GoF-Facade Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 1
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, structural, facade, simplification, subsystem, unified interface
+
+[%collapsible]
+====
+Full Name:: GoF Facade Pattern (Structural)
+
+[discrete]
+== *Intent*:
+Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.
+
+[discrete]
+== *When to Use*:
+* When you want to provide a simple interface to a complex subsystem
+* When there are many dependencies between clients and implementation classes
+
+[discrete]
+== *Prompt Example*:
+"Erstelle eine Facade nach GoF für das Payment-Subsystem, die Validierung, Autorisierung und Abrechnung hinter einem einfachen Interface kapselt."
+
+[discrete]
+== *Related Anchors*:
+* <<gof-design-patterns,GoF Design Patterns>> (Umbrella)
+====

docs/anchors/gof-factory-method-pattern.adoc

@@ -0,0 +1,31 @@
+= GoF-Factory Method Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 1
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, creational, factory, polymorphism, instantiation
+
+[%collapsible]
+====
+Full Name:: GoF Factory Method Pattern (Creational)
+
+Also known as:: Virtual Constructor
+
+[discrete]
+== *Intent*:
+Define an interface for creating an object, but let subclasses decide which class to instantiate.
+
+[discrete]
+== *When to Use*:
+* When a class can't anticipate the class of objects it must create
+* When a class wants its subclasses to specify the objects it creates
+
+[discrete]
+== *Prompt Example*:
+"Extrahiere die Objekterzeugung in eine Factory Method nach GoF, damit neue Typen ohne Änderung des bestehenden Codes hinzugefügt werden können."
+
+[discrete]
+== *Related Anchors*:
+* <<gof-design-patterns,GoF Design Patterns>> (Umbrella)
+====

docs/anchors/gof-flyweight-pattern.adoc

@@ -0,0 +1,16 @@
+= GoF-Flyweight Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 3
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, structural, flyweight, memory optimization, sharing
+
+[%collapsible]
+====
+Full Name:: GoF Flyweight Pattern (Structural)
+
+[discrete]
+== *Intent*:
+Use sharing to support large numbers of fine-grained objects efficiently.
+====

docs/anchors/gof-interpreter-pattern.adoc

@@ -0,0 +1,16 @@
+= GoF-Interpreter Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 3
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, behavioral, interpreter, grammar, DSL, parsing
+
+[%collapsible]
+====
+Full Name:: GoF Interpreter Pattern (Behavioral)
+
+[discrete]
+== *Intent*:
+Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.
+====

docs/anchors/gof-iterator-pattern.adoc

@@ -0,0 +1,30 @@
+= GoF-Iterator Pattern
+:categories: design-principles
+:roles: software-developer, software-architect
+:umbrella: gof-design-patterns
+:tier: 2
+:proponents: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
+:tags: GoF, design pattern, behavioral, iterator, traversal, collection, aggregate
+
+[%collapsible]
+====
+Full Name:: GoF Iterator Pattern (Behavioral)
+
+[discrete]
+== *Intent*:
+Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
+
+[discrete]
+== *When to Use*:
+* When you need to access an aggregate object's contents without exposing its internal representation
+* When you want to support multiple traversals of aggregate objects
+* When you want to provide a uniform interface for traversing different aggregate structures
+
+[discrete]
+== *Prompt Example*:
+"Implementiere einen Iterator nach GoF für die benutzerdefinierte Baumstruktur, der verschiedene Traversierungsstrategien (Tiefe, Breite) unterstützt."
+
+[discrete]
+== *Related Anchors*:
+* <<gof-design-patterns,GoF Design Patterns>> (Umbrella)
+====