claudient 0.1.0

package/rules/language-specific/es/go.md

@@ -0,0 +1,48 @@
+> 🇪🇸 Esta es la traducción en español. [Versión en inglés](../go.md).
+
+# Reglas de Go
+
+## Aplicar a
+Todos los archivos Go (`*.go`) en cualquier proyecto.
+
+## Reglas
+
+1. **Los errores son valores — envuelve con `%w`** — `fmt.Errorf("operation failed: %w", err)` preserva el error original para verificaciones con `errors.Is` y `errors.As`. Nunca descartes errores con `_`.
+
+2. **Pruebas orientadas a tablas** — usa patrones `[]struct{ name, input, want, wantErr }`. Cada caso tiene una sub-prueba `t.Run(tt.name, ...)`. Facilita agregar casos de prueba y hace los mensajes de fallo descriptivos.
+
+3. **Contexto como primer argumento** — cada función que hace I/O o bloquea toma `ctx context.Context` como su primer parámetro. Nunca almacenes el contexto en una estructura.
+
+4. **Define interfaces donde se consumen, no donde se implementan** — pon la interfaz en el paquete que la usa, no en el paquete que proporciona la implementación. Mantiene los paquetes desacoplados.
+
+5. **Máximo 1-3 métodos en las interfaces** — las interfaces más grandes son más difíciles de satisfacer y mockear. Si una interfaz tiene 8 métodos, considera dividirla.
+
+6. **`panic` solo para errores de programador verdaderamente irrecuperables** — configuración requerida faltante al inicio, invariantes violados que nunca deberían ocurrir. No para errores en tiempo de ejecución como "registro no encontrado".
+
+7. **Sin retornos desnudos** — `return x, nil` no solo `return`. Los valores de retorno nombrados están bien para documentación, pero los retornos desnudos oscurecen lo que se devuelve.
+
+8. **`init()` solo para efectos secundarios a nivel de paquete sin alternativa** — patrones de registro, inicialización de drivers. Nunca para cargar configuración o establecer conexiones — eso pertenece a `main` o un constructor.
+
+9. **`log/slog` para logging estructurado** — `slog.Info("request", "method", r.Method, "path", r.URL.Path)`. `fmt.Println` es solo para salida CLI.
+
+10. **`sync.Once` para inicialización lazy de singleton** — seguro para hilos, sin sobrecarga después de la primera llamada:
+    ```go
+    var (
+        instance *DB
+        once     sync.Once
+    )
+    func GetDB() *DB {
+        once.Do(func() { instance = newDB() })
+        return instance
+    }
+    ```
+
+11. **Embedding en lugar de herencia** — Go no tiene herencia. Compón tipos mediante embedding: `type AdminUser struct { User; AdminLevel int }`. Usa interfaces para polimorfismo.
+
+12. **Captura las variables del bucle explícitamente** — en goroutines dentro de bucles: `i, v := i, v` antes de `go func()`. En Go 1.22+, las variables del bucle son por iteración; en versiones anteriores son compartidas.
+
+13. **`errgroup` para operaciones concurrentes con propagación de errores** — `golang.org/x/sync/errgroup` sobre `WaitGroup` manual cuando necesitas devolver errores de goroutines.
+
+14. **Errores centinela para condiciones esperadas, errores tipados para errores estructurados** — `var ErrNotFound = errors.New("not found")` para condiciones simples. Tipos de error personalizados (implementando la interfaz `error`) cuando los llamadores necesitan inspeccionar campos.
+
+15. **Los manejadores HTTP obtienen solo `(w http.ResponseWriter, r *http.Request)`** — no embutes manejadores en structs ni uses closures para manejadores simples. Usa inyección de dependencias mediante un struct de manejador con un método `ServeHTTP` cuando se necesitan dependencias.

package/rules/language-specific/es/python.md

@@ -0,0 +1,38 @@
+> 🇪🇸 Esta es la traducción en español. [Versión en inglés](../python.md).
+
+# Reglas de Python
+
+## Aplicar a
+Todos los archivos Python (`*.py`) en cualquier proyecto.
+
+## Reglas
+
+1. **Type hints en todas las firmas de funciones** — parámetros y tipos de retorno. Usa `from __future__ import annotations` para referencias hacia adelante. Sin funciones sin tipado en código de producción.
+
+2. **`pathlib.Path` sobre `os.path`** — `Path("dir") / "file.txt"` es más limpio y funciona multiplataforma. `os.path` es legado.
+
+3. **f-strings sobre `.format()` y `%`** — `f"Hello {name}"` en todas partes. `.format()` solo cuando la plantilla se almacena como variable de cadena.
+
+4. **Nunca uses argumentos mutables por defecto** — `def fn(items: list = [])` crea una lista compartida en todas las llamadas. Usa `def fn(items: list | None = None)` y asigna dentro de la función.
+
+5. **`dataclasses` para contenedores de datos, `Pydantic` para datos externos validados** — si cruza un límite del sistema (HTTP, archivo, entorno), usa Pydantic. Si es estado puramente interno, `@dataclass` es más ligero.
+
+6. **Prefiere sentencias `with` para toda la gestión de recursos** — archivos, conexiones a BD, bloqueos, sesiones HTTP. Nunca llames `.close()` manualmente.
+
+7. **Expresiones generadoras sobre comprensiones de lista cuando solo iteras una vez** — `sum(x*x for x in range(1000))` no asigna una lista.
+
+8. **Define `__all__` en cada módulo público** — API pública explícita. Previene la contaminación de `import *` y documenta la intención.
+
+9. **Lanza excepciones específicas, captura excepciones específicas** — `raise ValueError("message")` no `raise Exception`. `except ValueError` no `except Exception` a menos que estés en un límite de error de nivel superior.
+
+10. **Módulo `logging` para código de producción, nunca `print()`** — `import logging; logger = logging.getLogger(__name__)`. `print()` solo en código de salida CLI.
+
+11. **Usa `Enum` para conjuntos fijos de valores** — no constantes de cadena. `class Status(str, Enum): ACTIVE = "active"` proporciona seguridad de tipos y completado en el IDE.
+
+12. **`subprocess.run()` sobre `os.system()`** — captura la salida, lanza en caso de fallo con `check=True`, evita inyección de shell con args de lista: `subprocess.run(["git", "status"], check=True)`.
+
+13. **`dict.get(key, default)` sobre `key in dict` + `dict[key]`** — una búsqueda en lugar de dos.
+
+14. **Clases base abstractas mediante `abc.ABC`** — cuando necesitas contratos de interfaz forzados. `Protocol` para subtipado estructural (duck typing con verificación de tipos).
+
+15. **Siempre entornos virtuales, dependencias en `pyproject.toml`** — `uv` o `poetry` para gestión. Sin `requirements.txt` para nuevos proyectos.

package/rules/language-specific/es/typescript.md

@@ -0,0 +1,51 @@
+> 🇪🇸 Esta es la traducción en español. [Versión en inglés](../typescript.md).
+
+# Reglas de TypeScript
+
+## Aplicar a
+Todos los archivos TypeScript (`*.ts`, `*.tsx`) en cualquier proyecto.
+
+## Reglas
+
+1. **`strict: true` en `tsconfig.json`** — siempre. Esto habilita `strictNullChecks`, `noImplicitAny` y `strictFunctionTypes`. Nunca deshabilites el modo estricto para silenciar errores; corrige los tipos.
+
+2. **`unknown` sobre `any` para datos externos sin tipo** — `any` deshabilita la verificación de tipos completamente. `unknown` te obliga a reducir el tipo antes de usarlo. Parsea datos externos con Zod o similar.
+
+3. **Operador `satisfies` para literales de objeto con verificación de tipos** — `const config = { port: 3000 } satisfies Config` detecta errores de tipo mientras preserva el tipo literal (sin ampliar a `Config`).
+
+4. **Unions discriminadas sobre campos nullable** — prefiere:
+   ```ts
+   type Result = { status: "ok"; data: User } | { status: "error"; message: string }
+   ```
+   sobre `{ data?: User; error?: string }`. Las unions discriminadas hacen posible la verificación exhaustiva con `switch`.
+
+5. **Sin aserciones de tipo `as` en código de producción** — `as SomeType` silencia al compilador sin verificar. Usa predicados de tipo o `satisfies` en su lugar. Excepción: consultas DOM donde TypeScript no puede inferir mejor.
+
+6. **Predicados de tipo para reducción** — `function isUser(v: unknown): v is User { return typeof v === "object" && v !== null && "email" in v }`.
+
+7. **`interface` para formas de objetos, `type` para unions y aliases** — `interface` soporta `extends` y fusión de declaraciones. `type` es necesario para unions y tipos mapeados.
+
+8. **Aserciones `const` para tipos literales** — `const ROLES = ["admin", "user"] as const` da el tipo `readonly ["admin", "user"]` en lugar de `string[]`.
+
+9. **Nunca uses el tipo `Function`** — usa firmas específicas: `(event: MouseEvent) => void`. `Function` acepta cualquier cosa y devuelve cualquier cosa.
+
+10. **Zod para validación en tiempo de ejecución de datos externos** — cuerpos de solicitudes HTTP, respuestas de API, variables de entorno, archivos de configuración. Los tipos de TypeScript son solo en tiempo de compilación; Zod valida en tiempo de ejecución:
+    ```ts
+    const UserSchema = z.object({ email: z.string().email(), age: z.number().int().positive() })
+    const user = UserSchema.parse(req.body)  // lanza ZodError si es inválido
+    ```
+
+11. **`readonly` en arrays y objetos que no deben mutarse** — `readonly string[]` previene push/splice. `Readonly<Config>` en objetos de configuración pasados a través de capas.
+
+12. **Tipos de retorno explícitos en funciones públicas/exportadas** — ayuda a la legibilidad y detecta cambios accidentales en el tipo de retorno.
+
+13. **`import type` para importaciones solo de tipos** — `import type { User } from './types'` se elimina en tiempo de ejecución y evita problemas de dependencia circular.
+
+14. **`never` para asegurar el manejo exhaustivo** — en el caso por defecto de un switch sobre una union discriminada:
+    ```ts
+    default:
+      const _exhaustive: never = status  // error de compilación si falta un caso
+      throw new Error(`Unhandled: ${_exhaustive}`)
+    ```
+
+15. **Habilita `noUncheckedIndexedAccess`** — el acceso a arrays y objetos por índice devuelve `T | undefined` en lugar de `T`, forzando verificaciones de null donde se necesitan.

package/rules/language-specific/fr/go.md

@@ -0,0 +1,48 @@
+> 🇫🇷 This is the French translation. [English version](../go.md).
+
+# Règles Go
+
+## S'applique à
+Tous les fichiers Go (`*.go`) dans n'importe quel projet.
+
+## Règles
+
+1. **Les erreurs sont des valeurs — envelopper avec `%w`** — `fmt.Errorf("operation failed: %w", err)` préserve l'erreur originale pour les vérifications `errors.Is` et `errors.As`. Ne jamais ignorer les erreurs avec `_`.
+
+2. **Tests table-driven** — utiliser des patterns `[]struct{ name, input, want, wantErr }`. Chaque cas a un sous-test `t.Run(tt.name, ...)`. Facilite l'ajout de cas de test et rend les messages d'échec descriptifs.
+
+3. **Context comme premier argument** — chaque fonction qui fait des I/O ou qui bloque prend `ctx context.Context` comme premier paramètre. Ne jamais stocker le context dans une struct.
+
+4. **Définir les interfaces là où elles sont consommées, pas là où elles sont implémentées** — placer l'interface dans le package qui l'utilise, pas dans le package qui fournit l'implémentation. Garde les packages découplés.
+
+5. **Interfaces de 1-3 méthodes maximum** — les interfaces plus grandes sont plus difficiles à satisfaire et à mocker. Si une interface a 8 méthodes, envisager de la diviser.
+
+6. **`panic` uniquement pour les erreurs de programmeur vraiment irrécupérables** — configuration requise manquante au démarrage, invariants violés qui ne devraient jamais arriver. Pas pour les erreurs runtime comme "record not found".
+
+7. **Pas de retours nus** — `return x, nil` pas juste `return`. Les valeurs de retour nommées sont acceptables pour la documentation, mais les retours nus obscurcissent ce qui est retourné.
+
+8. **`init()` uniquement pour les effets secondaires au niveau package sans alternative** — patterns d'enregistrement, init de driver. Jamais pour charger la config ou établir des connexions — ça appartient à `main` ou un constructeur.
+
+9. **`log/slog` pour le logging structuré** — `slog.Info("request", "method", r.Method, "path", r.URL.Path)`. `fmt.Println` est uniquement pour la sortie CLI.
+
+10. **`sync.Once` pour l'initialisation paresseuse de singleton** — thread-safe, zéro surcoût après le premier appel :
+    ```go
+    var (
+        instance *DB
+        once     sync.Once
+    )
+    func GetDB() *DB {
+        once.Do(func() { instance = newDB() })
+        return instance
+    }
+    ```
+
+11. **Embed plutôt qu'héritage** — Go n'a pas d'héritage. Composer les types via embedding : `type AdminUser struct { User; AdminLevel int }`. Utiliser les interfaces pour le polymorphisme.
+
+12. **Capturer les variables de boucle explicitement** — dans les goroutines à l'intérieur des boucles : `i, v := i, v` avant le `go func()`. En Go 1.22+, les variables de boucle sont par itération ; dans les versions antérieures elles sont partagées.
+
+13. **`errgroup` pour les opérations concurrentes avec propagation d'erreurs** — `golang.org/x/sync/errgroup` plutôt que `WaitGroup` manuel quand vous devez retourner des erreurs depuis des goroutines.
+
+14. **Erreurs sentinelles pour les conditions attendues, erreurs typées pour les erreurs structurées** — `var ErrNotFound = errors.New("not found")` pour les conditions simples. Types d'erreur personnalisés (implémentant l'interface `error`) quand les appelants doivent inspecter des champs.
+
+15. **Les handlers HTTP reçoivent uniquement `(w http.ResponseWriter, r *http.Request)`** — ne pas imbriquer les handlers dans des structs ou utiliser des fermetures pour les handlers simples. Utiliser l'injection de dépendances via une struct handler avec une méthode `ServeHTTP` quand des dépendances sont nécessaires.

package/rules/language-specific/fr/python.md

@@ -0,0 +1,38 @@
+> 🇫🇷 This is the French translation. [English version](../python.md).
+
+# Règles Python
+
+## S'applique à
+Tous les fichiers Python (`*.py`) dans n'importe quel projet.
+
+## Règles
+
+1. **Annotations de type sur toutes les signatures de fonctions** — paramètres et types de retour. Utiliser `from __future__ import annotations` pour les références en avant. Pas de fonctions non typées en code de production.
+
+2. **`pathlib.Path` plutôt que `os.path`** — `Path("dir") / "file.txt"` est plus propre et fonctionne sur toutes les plateformes. `os.path` est du code legacy.
+
+3. **f-strings plutôt que `.format()` et `%`** — `f"Hello {name}"` partout. `.format()` uniquement quand le template est stocké dans une variable chaîne.
+
+4. **Ne jamais utiliser des arguments par défaut mutables** — `def fn(items: list = [])` crée une liste unique partagée entre tous les appels. Utiliser `def fn(items: list | None = None)` et assigner à l'intérieur.
+
+5. **`dataclasses` pour les conteneurs de données, `Pydantic` pour les données externes validées** — si elles traversent une frontière système (HTTP, fichier, env), utiliser Pydantic. Si c'est uniquement un état interne, `@dataclass` est plus léger.
+
+6. **Préférer les instructions `with` pour toute gestion de ressources** — fichiers, connexions DB, verrous, sessions HTTP. Ne jamais appeler `.close()` manuellement.
+
+7. **Expressions génératrices plutôt que compréhensions de listes quand vous n'itérez qu'une fois** — `sum(x*x for x in range(1000))` n'alloue pas de liste.
+
+8. **Définir `__all__` dans chaque module public** — API publique explicite. Évite la pollution des `import *` et documente l'intention.
+
+9. **Lever des exceptions spécifiques, attraper des exceptions spécifiques** — `raise ValueError("message")` pas `raise Exception`. `except ValueError` pas `except Exception` sauf à une frontière d'erreur de niveau supérieur.
+
+10. **Module `logging` pour le code de production, jamais `print()`** — `import logging; logger = logging.getLogger(__name__)`. `print()` uniquement dans le code de sortie CLI.
+
+11. **Utiliser `Enum` pour les ensembles de valeurs fixes** — pas des constantes chaînes. `class Status(str, Enum): ACTIVE = "active"` donne la sécurité de type et la complétion IDE.
+
+12. **`subprocess.run()` plutôt que `os.system()`** — capture la sortie, lève sur échec avec `check=True`, évite l'injection shell avec des args en liste : `subprocess.run(["git", "status"], check=True)`.
+
+13. **`dict.get(key, default)` plutôt que `key in dict` + `dict[key]`** — une recherche au lieu de deux.
+
+14. **Classes de base abstraites via `abc.ABC`** — quand vous avez besoin de contrats d'interface appliqués. `Protocol` pour le sous-typage structurel (duck typing avec vérification de type).
+
+15. **Environnements virtuels toujours, dépendances dans `pyproject.toml`** — `uv` ou `poetry` pour la gestion. Pas de `requirements.txt` pour les nouveaux projets.

package/rules/language-specific/fr/typescript.md

@@ -0,0 +1,51 @@
+> 🇫🇷 This is the French translation. [English version](../typescript.md).
+
+# Règles TypeScript
+
+## S'applique à
+Tous les fichiers TypeScript (`*.ts`, `*.tsx`) dans n'importe quel projet.
+
+## Règles
+
+1. **`strict: true` dans `tsconfig.json`** — toujours. Cela active `strictNullChecks`, `noImplicitAny` et `strictFunctionTypes`. Ne jamais désactiver le mode strict pour faire taire des erreurs ; corriger les types.
+
+2. **`unknown` plutôt que `any` pour les données externes non typées** — `any` désactive complètement la vérification de type. `unknown` vous oblige à restreindre le type avant utilisation. Analyser les données externes avec Zod ou similaire.
+
+3. **Opérateur `satisfies` pour les littéraux d'objets vérifiés par type** — `const config = { port: 3000 } satisfies Config` détecte les erreurs de type tout en préservant le type littéral (sans l'élargir à `Config`).
+
+4. **Unions discriminées plutôt que champs nullable** — préférer :
+   ```ts
+   type Result = { status: "ok"; data: User } | { status: "error"; message: string }
+   ```
+   plutôt que `{ data?: User; error?: string }`. Les unions discriminées permettent une vérification exhaustive avec `switch`.
+
+5. **Pas d'assertions de type `as` dans le code de production** — `as SomeType` fait taire le compilateur sans vérifier. Utiliser des prédicats de type ou `satisfies` à la place. Exception : requêtes DOM où TypeScript ne peut pas inférer mieux.
+
+6. **Prédicats de type pour la restriction** — `function isUser(v: unknown): v is User { return typeof v === "object" && v !== null && "email" in v }`.
+
+7. **`interface` pour les formes d'objets, `type` pour les unions et les alias** — `interface` supporte `extends` et la fusion de déclarations. `type` est nécessaire pour les unions et les types mappés.
+
+8. **Assertions `const` pour les types littéraux** — `const ROLES = ["admin", "user"] as const` donne le type `readonly ["admin", "user"]` plutôt que `string[]`.
+
+9. **Ne jamais utiliser le type `Function`** — utiliser des signatures spécifiques : `(event: MouseEvent) => void`. `Function` accepte tout et retourne tout.
+
+10. **Zod pour la validation à l'exécution des données externes** — corps de requêtes HTTP, réponses API, variables d'env, fichiers de config. Les types TypeScript ne sont que temps de compilation ; Zod valide à l'exécution :
+    ```ts
+    const UserSchema = z.object({ email: z.string().email(), age: z.number().int().positive() })
+    const user = UserSchema.parse(req.body)  // lève ZodError si invalide
+    ```
+
+11. **`readonly` sur les tableaux et objets qui ne doivent pas être mutés** — `readonly string[]` empêche push/splice. `Readonly<Config>` sur les objets de config passés à travers les couches.
+
+12. **Types de retour explicites sur les fonctions publiques/exportées** — aide à la lisibilité et détecte les changements accidentels de type de retour.
+
+13. **`import type` pour les imports uniquement de type** — `import type { User } from './types'` est effacé à l'exécution et évite les problèmes de dépendances circulaires.
+
+14. **`never` pour assurer une gestion exhaustive** — dans le cas par défaut d'un switch sur une union discriminée :
+    ```ts
+    default:
+      const _exhaustive: never = status  // erreur de compilation si un cas manque
+      throw new Error(`Unhandled: ${_exhaustive}`)
+    ```
+
+15. **Activer `noUncheckedIndexedAccess`** — l'accès par index aux tableaux et objets retourne `T | undefined` plutôt que `T`, forçant les vérifications null là où elles sont nécessaires.

package/rules/language-specific/go.md

@@ -0,0 +1,46 @@
+# Go Rules
+
+## Apply to
+All Go files (`*.go`) in any project.
+
+## Rules
+
+1. **Errors are values — wrap with `%w`** — `fmt.Errorf("operation failed: %w", err)` preserves the original error for `errors.Is` and `errors.As` checks. Never discard errors with `_`.
+
+2. **Table-driven tests** — use `[]struct{ name, input, want, wantErr }` patterns. Each case has a `t.Run(tt.name, ...)` sub-test. Makes test cases easy to add and failure messages descriptive.
+
+3. **Context as first argument** — every function that does I/O or blocks takes `ctx context.Context` as its first parameter. Never store context in a struct.
+
+4. **Define interfaces where they're consumed, not where implemented** — put the interface in the package that uses it, not the package that provides the implementation. Keeps packages decoupled.
+
+5. **Interfaces 1-3 methods max** — larger interfaces are harder to satisfy and mock. If an interface has 8 methods, consider splitting it.
+
+6. **`panic` only for truly unrecoverable programmer errors** — missing required configuration at startup, violated invariants that should never happen. Not for runtime errors like "record not found".
+
+7. **No naked returns** — `return x, nil` not just `return`. Named return values are fine for documentation, but naked returns obscure what's being returned.
+
+8. **`init()` only for package-level side effects with no alternative** — registration patterns, driver init. Never for loading config or establishing connections — that belongs in `main` or a constructor.
+
+9. **`log/slog` for structured logging** — `slog.Info("request", "method", r.Method, "path", r.URL.Path)`. `fmt.Println` is for CLI output only.
+
+10. **`sync.Once` for lazy singleton initialization** — thread-safe, zero overhead after first call:
+    ```go
+    var (
+        instance *DB
+        once     sync.Once
+    )
+    func GetDB() *DB {
+        once.Do(func() { instance = newDB() })
+        return instance
+    }
+    ```
+
+11. **Embed don't inherit** — Go has no inheritance. Compose types via embedding: `type AdminUser struct { User; AdminLevel int }`. Use interfaces for polymorphism.
+
+12. **Capture loop variables explicitly** — in goroutines inside loops: `i, v := i, v` before the `go func()`. In Go 1.22+, loop variables are per-iteration; in earlier versions they're shared.
+
+13. **`errgroup` for concurrent operations with error propagation** — `golang.org/x/sync/errgroup` over manual `WaitGroup` when you need to return errors from goroutines.
+
+14. **Sentinel errors for expected conditions, typed errors for structured errors** — `var ErrNotFound = errors.New("not found")` for simple conditions. Custom error types (implementing `error` interface) when callers need to inspect fields.
+
+15. **HTTP handlers get only `(w http.ResponseWriter, r *http.Request)`** — don't embed handlers in structs or use closures for simple handlers. Use dependency injection via a handler struct with a `ServeHTTP` method when dependencies are needed.

package/rules/language-specific/nl/go.md

@@ -0,0 +1,48 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../go.md).
+
+# Go-regels
+
+## Van toepassing op
+Alle Go-bestanden (`*.go`) in elk project.
+
+## Regels
+
+1. **Fouten zijn waarden — wikkel in met `%w`** — `fmt.Errorf("operation failed: %w", err)` behoudt de oorspronkelijke fout voor `errors.Is`- en `errors.As`-controles. Gooi nooit fouten weg met `_`.
+
+2. **Tabelgestuurde tests** — gebruik `[]struct{ name, input, want, wantErr }`-patronen. Elk geval heeft een `t.Run(tt.name, ...)`-subtest. Maakt testgevallen eenvoudig toe te voegen en foutberichten beschrijvend.
+
+3. **Context als eerste argument** — elke functie die I/O doet of blokkeert neemt `ctx context.Context` als eerste parameter. Sla nooit context op in een struct.
+
+4. **Definieer interfaces waar ze worden verbruikt, niet waar geïmplementeerd** — zet de interface in het pakket dat het gebruikt, niet het pakket dat de implementatie biedt. Houdt pakketten ontkoppeld.
+
+5. **Interfaces maximaal 1-3 methoden** — grotere interfaces zijn moeilijker te voldoen en te mocken. Als een interface 8 methoden heeft, overweeg dan te splitsen.
+
+6. **`panic` alleen voor echt onherstelbare programmeursfouten** — ontbrekende vereiste configuratie bij opstarten, geschonden invarianten die nooit mogen voorkomen. Niet voor runtime-fouten zoals "record not found".
+
+7. **Geen naakte returns** — `return x, nil` niet gewoon `return`. Benoemde retourwaarden zijn goed voor documentatie, maar naakte returns verhullen wat er wordt geretourneerd.
+
+8. **`init()` alleen voor bijeffecten op pakketniveau zonder alternatief** — registratiepatronen, driver-init. Nooit voor het laden van configuratie of het opzetten van verbindingen — dat hoort in `main` of een constructor.
+
+9. **`log/slog` voor gestructureerde logging** — `slog.Info("request", "method", r.Method, "path", r.URL.Path)`. `fmt.Println` is alleen voor CLI-output.
+
+10. **`sync.Once` voor luie singleton-initialisatie** — thread-safe, nul overhead na eerste aanroep:
+    ```go
+    var (
+        instance *DB
+        once     sync.Once
+    )
+    func GetDB() *DB {
+        once.Do(func() { instance = newDB() })
+        return instance
+    }
+    ```
+
+11. **Embed, niet erven** — Go heeft geen overerving. Stel typen samen via embedding: `type AdminUser struct { User; AdminLevel int }`. Gebruik interfaces voor polymorfisme.
+
+12. **Vang loopvariabelen expliciet** — in goroutines binnen lussen: `i, v := i, v` vóór de `go func()`. In Go 1.22+ zijn loopvariabelen per iteratie; in eerdere versies zijn ze gedeeld.
+
+13. **`errgroup` voor gelijktijdige operaties met foutpropagatie** — `golang.org/x/sync/errgroup` boven handmatige `WaitGroup` wanneer je fouten moet retourneren vanuit goroutines.
+
+14. **Sentinaelfouten voor verwachte omstandigheden, getypeerde fouten voor gestructureerde fouten** — `var ErrNotFound = errors.New("not found")` voor eenvoudige omstandigheden. Aangepaste fouttypen (die de `error`-interface implementeren) wanneer aanroepers velden moeten inspecteren.
+
+15. **HTTP-handlers krijgen alleen `(w http.ResponseWriter, r *http.Request)`** — bed handlers niet in in structs of gebruik closures voor eenvoudige handlers. Gebruik dependency injection via een handler-struct met een `ServeHTTP`-methode wanneer afhankelijkheden nodig zijn.

package/rules/language-specific/nl/python.md

@@ -0,0 +1,38 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../python.md).
+
+# Python-regels
+
+## Van toepassing op
+Alle Python-bestanden (`*.py`) in elk project.
+
+## Regels
+
+1. **Type-hints op alle functiesignaturen** — parameters en retourtypen. Gebruik `from __future__ import annotations` voor voorwaartse verwijzingen. Geen ongetypeerde bare functies in productiecode.
+
+2. **`pathlib.Path` boven `os.path`** — `Path("dir") / "file.txt"` is schoner en werkt cross-platform. `os.path` is verouderd.
+
+3. **f-strings boven `.format()` en `%`** — `f"Hello {name}"` overal. `.format()` alleen als de sjabloon is opgeslagen als een stringvariabele.
+
+4. **Gebruik nooit veranderlijke standaardargumenten** — `def fn(items: list = [])` maakt één lijst gedeeld over alle aanroepen. Gebruik `def fn(items: list | None = None)` en wijs binnenin toe.
+
+5. **`dataclasses` voor datacontainers, `Pydantic` voor gevalideerde externe data** — als het een systeemgrens overschrijdt (HTTP, bestand, omgeving), gebruik Pydantic. Als het puur interne state is, is `@dataclass` lichter.
+
+6. **Geef de voorkeur aan `with`-statements voor alle resourcebeheer** — bestanden, DB-verbindingen, locks, HTTP-sessies. Roep nooit handmatig `.close()` aan.
+
+7. **Generator-expressies boven lijstbegrippen wanneer je slechts eenmaal itereert** — `sum(x*x for x in range(1000))` alloceert geen lijst.
+
+8. **Definieer `__all__` in elke publieke module** — expliciete publieke API. Voorkomt `import *`-vervuiling en documenteert intentie.
+
+9. **Gooi specifieke uitzonderingen, vang specifieke uitzonderingen** — `raise ValueError("message")` niet `raise Exception`. `except ValueError` niet `except Exception` tenzij je op een top-level foutgrens bent.
+
+10. **`logging`-module voor productiecode, nooit `print()`** — `import logging; logger = logging.getLogger(__name__)`. `print()` alleen in CLI-outputcode.
+
+11. **Gebruik `Enum` voor vaste sets van waarden** — geen stringconstanten. `class Status(str, Enum): ACTIVE = "active"` geeft typeveiligheid en IDE-aanvulling.
+
+12. **`subprocess.run()` boven `os.system()`** — legt output vast, gooit bij mislukking met `check=True`, vermijdt shell-injectie met lijstargumenten: `subprocess.run(["git", "status"], check=True)`.
+
+13. **`dict.get(key, default)` boven `key in dict` + `dict[key]`** — één opzoekactie in plaats van twee.
+
+14. **Abstracte basisklassen via `abc.ABC`** — wanneer je afgedwongen interfacecontracten nodig hebt. `Protocol` voor structureel subtypen (duck typing met typecontrole).
+
+15. **Altijd virtuele omgevingen, afhankelijkheden in `pyproject.toml`** — `uv` of `poetry` voor beheer. Geen `requirements.txt` voor nieuwe projecten.

package/rules/language-specific/nl/typescript.md

@@ -0,0 +1,51 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../typescript.md).
+
+# TypeScript-regels
+
+## Van toepassing op
+Alle TypeScript-bestanden (`*.ts`, `*.tsx`) in elk project.
+
+## Regels
+
+1. **`strict: true` in `tsconfig.json`** — altijd. Dit schakelt `strictNullChecks`, `noImplicitAny` en `strictFunctionTypes` in. Schakel strict-modus nooit uit om fouten te onderdrukken; herstel de typen.
+
+2. **`unknown` boven `any` voor ongetypeerde externe data** — `any` schakelt typecontrole volledig uit. `unknown` dwingt je het type te vernauwen voor gebruik. Parseer externe data met Zod of vergelijkbaar.
+
+3. **`satisfies`-operator voor gecontroleerde objectliteralen** — `const config = { port: 3000 } satisfies Config` vangt typefouten terwijl het letterlijke type behouden blijft (niet verbreed naar `Config`).
+
+4. **Gediscrimineerde unions boven nullable velden** — geef de voorkeur aan:
+   ```ts
+   type Result = { status: "ok"; data: User } | { status: "error"; message: string }
+   ```
+   boven `{ data?: User; error?: string }`. Gediscrimineerde unions maken uitputtende `switch`-controle mogelijk.
+
+5. **Geen `as`-typebeweringen in productiecode** — `as SomeType` maakt de compiler stil zonder te controleren. Gebruik type-predicaten of `satisfies` in plaats daarvan. Uitzondering: DOM-queries waarbij TypeScript niet beter kan afleiden.
+
+6. **Type-predicaten voor vernauwen** — `function isUser(v: unknown): v is User { return typeof v === "object" && v !== null && "email" in v }`.
+
+7. **`interface` voor objectvormen, `type` voor unions en aliassen** — `interface` ondersteunt `extends` en declaratiesamenvoegen. `type` is nodig voor unions en gemapte typen.
+
+8. **`const`-beweringen voor letterlijke typen** — `const ROLES = ["admin", "user"] as const` geeft type `readonly ["admin", "user"]` in plaats van `string[]`.
+
+9. **Gebruik nooit het `Function`-type** — gebruik specifieke signaturen: `(event: MouseEvent) => void`. `Function` accepteert alles en retourneert alles.
+
+10. **Zod voor runtime-validatie van externe data** — HTTP-verzoekbodies, API-antwoorden, omgevingsvariabelen, configuratiebestanden. TypeScript-typen zijn alleen compilatie-tijd; Zod valideert tijdens runtime:
+    ```ts
+    const UserSchema = z.object({ email: z.string().email(), age: z.number().int().positive() })
+    const user = UserSchema.parse(req.body)  // gooit ZodError als ongeldig
+    ```
+
+11. **`readonly` op arrays en objecten die niet gemuteerd mogen worden** — `readonly string[]` voorkomt push/splice. `Readonly<Config>` op configuratieobjecten die door lagen worden doorgegeven.
+
+12. **Expliciete retourtypen op publieke/geëxporteerde functies** — bevordert leesbaarheid en vangt onbedoelde retourtype-wijzigingen.
+
+13. **`import type` voor alleen-type imports** — `import type { User } from './types'` wordt gewist tijdens runtime en vermijdt circulaire afhankelijkheidsproblemen.
+
+14. **`never` om uitputtende afhandeling te garanderen** — in het standaardgeval van een switch over een gediscrimineerde union:
+    ```ts
+    default:
+      const _exhaustive: never = status  // compilatiefout als een geval ontbreekt
+      throw new Error(`Unhandled: ${_exhaustive}`)
+    ```
+
+15. **Schakel `noUncheckedIndexedAccess` in** — array- en objectindextoegang retourneert `T | undefined` in plaats van `T`, waardoor null-controles worden afgedwongen waar nodig.

package/rules/language-specific/python.md

@@ -0,0 +1,36 @@
+# Python Rules
+
+## Apply to
+All Python files (`*.py`) in any project.
+
+## Rules
+
+1. **Type hints on all function signatures** — parameters and return types. Use `from __future__ import annotations` for forward references. No bare untyped functions in production code.
+
+2. **`pathlib.Path` over `os.path`** — `Path("dir") / "file.txt"` is cleaner and works cross-platform. `os.path` is legacy.
+
+3. **f-strings over `.format()` and `%`** — `f"Hello {name}"` everywhere. `.format()` only when the template is stored as a string variable.
+
+4. **Never use mutable default arguments** — `def fn(items: list = [])` creates one list shared across all calls. Use `def fn(items: list | None = None)` and assign inside.
+
+5. **`dataclasses` for data containers, `Pydantic` for validated external data** — if it crosses a system boundary (HTTP, file, env), use Pydantic. If it's purely internal state, `@dataclass` is lighter.
+
+6. **Prefer `with` statements for all resource management** — files, DB connections, locks, HTTP sessions. Never call `.close()` manually.
+
+7. **Generator expressions over list comprehensions when you only iterate once** — `sum(x*x for x in range(1000))` doesn't allocate a list.
+
+8. **Define `__all__` in every public module** — explicit public API. Prevents `import *` pollution and documents intent.
+
+9. **Raise specific exceptions, catch specific exceptions** — `raise ValueError("message")` not `raise Exception`. `except ValueError` not `except Exception` unless you're at a top-level error boundary.
+
+10. **`logging` module for production code, never `print()`** — `import logging; logger = logging.getLogger(__name__)`. `print()` only in CLI output code.
+
+11. **Use `Enum` for fixed sets of values** — not string constants. `class Status(str, Enum): ACTIVE = "active"` gives type safety and IDE completion.
+
+12. **`subprocess.run()` over `os.system()`** — captures output, raises on failure with `check=True`, avoids shell injection with list args: `subprocess.run(["git", "status"], check=True)`.
+
+13. **`dict.get(key, default)` over `key in dict` + `dict[key]`** — one lookup instead of two.
+
+14. **Abstract base classes via `abc.ABC`** — when you need enforced interface contracts. `Protocol` for structural subtyping (duck typing with type checking).
+
+15. **Virtual environments always, dependencies in `pyproject.toml`** — `uv` or `poetry` for management. No `requirements.txt` for new projects.

package/rules/language-specific/typescript.md

@@ -0,0 +1,49 @@
+# TypeScript Rules
+
+## Apply to
+All TypeScript files (`*.ts`, `*.tsx`) in any project.
+
+## Rules
+
+1. **`strict: true` in `tsconfig.json`** — always. This enables `strictNullChecks`, `noImplicitAny`, and `strictFunctionTypes`. Never disable strict mode to silence errors; fix the types.
+
+2. **`unknown` over `any` for untyped external data** — `any` disables type checking entirely. `unknown` forces you to narrow the type before use. Parse external data with Zod or similar.
+
+3. **`satisfies` operator for type-checked object literals** — `const config = { port: 3000 } satisfies Config` catches type errors while preserving the literal type (not widening to `Config`).
+
+4. **Discriminated unions over nullable fields** — prefer:
+   ```ts
+   type Result = { status: "ok"; data: User } | { status: "error"; message: string }
+   ```
+   over `{ data?: User; error?: string }`. Discriminated unions make exhaustive `switch` checking possible.
+
+5. **No `as` type assertions in production code** — `as SomeType` silences the compiler without checking. Use type predicates or `satisfies` instead. Exception: DOM queries where TypeScript can't infer better.
+
+6. **Type predicates for narrowing** — `function isUser(v: unknown): v is User { return typeof v === "object" && v !== null && "email" in v }`.
+
+7. **`interface` for object shapes, `type` for unions and aliases** — `interface` supports `extends` and declaration merging. `type` is needed for unions and mapped types.
+
+8. **`const` assertions for literal types** — `const ROLES = ["admin", "user"] as const` gives type `readonly ["admin", "user"]` instead of `string[]`.
+
+9. **Never use the `Function` type** — use specific signatures: `(event: MouseEvent) => void`. `Function` accepts anything and returns anything.
+
+10. **Zod for runtime validation of external data** — HTTP request bodies, API responses, env vars, config files. TypeScript types are compile-time only; Zod validates at runtime:
+    ```ts
+    const UserSchema = z.object({ email: z.string().email(), age: z.number().int().positive() })
+    const user = UserSchema.parse(req.body)  // throws ZodError if invalid
+    ```
+
+11. **`readonly` on arrays and objects that shouldn't be mutated** — `readonly string[]` prevents push/splice. `Readonly<Config>` on config objects passed through layers.
+
+12. **Explicit return types on public/exported functions** — aids readability and catches accidental return type changes.
+
+13. **`import type` for type-only imports** — `import type { User } from './types'` is erased at runtime and avoids circular dependency issues.
+
+14. **`never` to ensure exhaustive handling** — in the default case of a switch over a discriminated union:
+    ```ts
+    default:
+      const _exhaustive: never = status  // compile error if a case is missing
+      throw new Error(`Unhandled: ${_exhaustive}`)
+    ```
+
+15. **Enable `noUncheckedIndexedAccess`** — array and object index access returns `T | undefined` instead of `T`, forcing null checks where they're needed.