repowarden 0.0.0-stage → 4.1.0

package/bin/ticket

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+# Travailler à partir d'un ticket : le ticket d'abord, la branche en découle.
+#   repowarden ticket <n>                    prend le ticket (assigné à soi) et se place sur
+#                                            sa branche ; la crée, liée au ticket, au besoin
+#   repowarden ticket nouveau "<titre>" [--type fix] [--description "…"]
+#                                            crée le ticket (« à valider » si le suivi
+#                                            est géré par repowarden, sinon avec sa branche)
+#   repowarden ticket                        ticket de la branche courante
+# Demande un gh connecté (https://cli.github.com).
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+# shellcheck source=../hooks/lib/common.sh
+source "$ROOT/hooks/lib/common.sh"
+# shellcheck source=../hooks/lib/tickets.sh
+source "$ROOT/hooks/lib/tickets.sh"
+
+aide() { sed -n '2,9p' "$0" | sed 's/^# \{0,1\}//'; }
+
+[ -n "$GIT_TOPLEVEL" ] || { err_t install.not_repo; exit 1; }
+cd "$GIT_TOPLEVEL"
+
+# Se place sur la branche $1 (locale, ou suivie depuis origin)
+switch_to() {
+    if git show-ref -q --verify "refs/heads/$1"; then
+        git switch -q "$1"
+    else
+        git switch -q --track -c "$1" "origin/$1"
+    fi
+}
+
+# Prendre le ticket $1 : assigné à soi (le suivi le passe en cours)
+prendre() { gh issue edit "$1" --add-assignee @me >/dev/null 2>&1 || true; }
+
+cmd_ticket() {
+    local n="$1" json etat titre etiquettes base
+    command -v gh >/dev/null || { err_t bot.no_gh; exit 1; }
+    step_t tk.cli.fetch "$n"
+    git fetch -q origin --prune
+    ticket_remote_branch_r "$n"
+    if [ -n "$REPLY" ]; then
+        switch_to "$REPLY"
+        prendre "$n"
+        ok_t tk.cli.switched "$REPLY" "$n"
+        return 0
+    fi
+    json="$(gh issue view "$n" --json state,title,labels \
+        -q '[.state, .title, ([.labels[].name] | join("\n"))] | @tsv')"
+    IFS=$'\t' read -r etat titre etiquettes <<<"$json"
+    etiquettes="${etiquettes//\\n/$'\n'}"
+    if [ "$etat" != OPEN ]; then
+        err_t tk.cli.closed "$n"
+        exit 1
+    fi
+    # Suivi géré par repowarden : la branche naît de la validation
+    if tickets_managed && ! grep -qxF "$VALIDE" <<<"$etiquettes"; then
+        err_t tk.cli.not_validated "$n" "$VALIDE"
+        exit 1
+    fi
+    ticket_type_r "$etiquettes"
+    ticket_branch_r "$n" "$titre" "$REPLY"
+    local branche="$REPLY"
+    ticket_base_r
+    base="$REPLY"
+    gh issue develop "$n" --name "$branche" --base "$base" --checkout >/dev/null
+    prendre "$n"
+    ok_t tk.cli.created_branch "$branche" "$base" "$n"
+}
+
+cmd_nouveau() {
+    local titre="" type="" description="" porcelain="" url n etiquettes=()
+    while [ $# -gt 0 ]; do
+        case "$1" in
+            --type) shift; type="${1:?--type attend un type}" ;;
+            --description) shift; description="${1:?--description attend un texte}" ;;
+            --porcelain) porcelain=1 ;;
+            -*) err_t install.unknown_arg "$1"; exit 1 ;;
+            *) titre="$1" ;;
+        esac
+        shift
+    done
+    [ -n "$titre" ] || { err_t tk.cli.title_required; exit 1; }
+    command -v gh >/dev/null || { err_t bot.no_gh; exit 1; }
+    if tickets_managed; then
+        etiquettes+=(--label "$S_AVALIDER")
+        [ -z "$type" ] || etiquettes+=(--label "type: $type")
+    fi
+    _tr tk.cli.issue_body
+    url="$(gh issue create --title "$titre" --body "${description:-$_T}" ${etiquettes[@]+"${etiquettes[@]}"})"
+    n="${url##*/}"
+    if [ -n "$porcelain" ]; then
+        echo "$n"
+        return 0
+    fi
+    if tickets_managed; then
+        ok_t tk.cli.issue_created "$n" "$n"
+    else
+        # Sans suivi automatique, pas d'étape de validation : la branche suit
+        ok_t tk.cli.issue_created_branch "$n"
+        ticket_branch_r "$n" "$titre" "${type:-feat}"
+        local branche="$REPLY"
+        ticket_base_r
+        gh issue develop "$n" --name "$branche" --base "$REPLY" --checkout >/dev/null
+        ok_t tk.cli.created_branch "$branche" "$REPLY" "$n"
+    fi
+}
+
+case "${1:-}" in
+    -h | --help | help) aide ;;
+    nouveau | new) shift; cmd_nouveau "$@" ;;
+    "")
+        branche="$(git symbolic-ref --short HEAD 2>/dev/null || echo "")"
+        branch_ticket_r "$branche"
+        if [ -n "$REPLY" ]; then
+            info_t tk.cli.current "$branche" "$REPLY"
+        else
+            ticket_hint "$branche"
+        fi
+        ;;
+    *)
+        if [[ "$1" =~ ^#?[0-9]+$ ]]; then
+            cmd_ticket "${1#\#}"
+        else
+            err_t install.unknown_arg "$1"
+            aide >&2
+            exit 1
+        fi
+        ;;
+esac

package/bin/tickets

@@ -0,0 +1,135 @@
+#!/usr/bin/env bash
+# Prépare le suivi des tickets d'un dépôt GitHub (relançable sans risque) :
+#   repowarden tickets init [--repo propriétaire/nom] [--sans-validation-auto]
+#   repowarden tickets sync   branches locales des tickets qui me sont assignés
+#                             (aussi automatique : réglage ticketSync = auto|manual|off)
+#   - étiquettes : « validé », les statuts (à valider, backlog, en cours,
+#     en relecture, préprod, done) et les types (type: feat, type: fix…), qui
+#     donnent le préfixe de la branche du ticket ;
+#   - modèle de ticket .github/ISSUE_TEMPLATE/ticket.yml (créé « à valider ») ;
+#   - workflow .github/workflows/tickets.yml (s'ils n'existent pas déjà) ;
+#   - tickets existants : sans statut, rangés (validé ou ouverts par un
+#     mainteneur → backlog, sinon à valider ; --sans-validation-auto : tous à
+#     valider) ; branches des PR ouvertes et mergées inscrites sur leurs tickets.
+# Ensuite : committer ces fichiers, exiger la vérification « ticket »
+# (repowarden proteger --checks "…,ticket") et brancher le job tickets de release.yml.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+# shellcheck source=../hooks/lib/common.sh
+source "$ROOT/hooks/lib/common.sh"
+
+REPO=""
+commande="${1:-}"
+[ $# -eq 0 ] || shift
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --repo) shift; REPO="${1:?--repo attend propriétaire/nom}" ;;
+        --sans-validation-auto) AUTO_VALIDATE=never ;;
+        *) err_t install.unknown_arg "$1"; exit 1 ;;
+    esac
+    shift
+done
+if [ "$commande" = sync ]; then
+    # shellcheck source=../hooks/lib/tickets.sh
+    source "$ROOT/hooks/lib/tickets.sh"
+    command -v gh >/dev/null || { err_t bot.no_gh; exit 1; }
+    [ -n "$GIT_TOPLEVEL" ] || { err_t install.not_repo; exit 1; }
+    cd "$GIT_TOPLEVEL"
+    tickets_sync force
+    ok_t tk.sync.done
+    exit 0
+fi
+if [ "$commande" != init ]; then
+    sed -n '2,15p' "$0" | sed 's/^# \{0,1\}//'
+    [ "$commande" = "" ] || [ "$commande" = -h ] || [ "$commande" = --help ]
+    exit
+fi
+
+command -v gh >/dev/null || { err_t bot.no_gh; exit 1; }
+[ -n "$GIT_TOPLEVEL" ] || { err_t install.not_repo; exit 1; }
+cd "$GIT_TOPLEVEL"
+[ -n "$REPO" ] || REPO="$(gh repo view --json nameWithOwner -q .nameWithOwner)"
+brand "tickets · $REPO"
+
+# 1. Étiquettes (créées ou mises à jour)
+step_t tk.init_labels
+while IFS='|' read -r nom couleur description; do
+    gh label create "$nom" --repo "$REPO" --color "$couleur" --description "$description" --force >/dev/null
+    echo "  $nom"
+done <<'ETIQUETTES'
+validé|0e8a16|Ticket accepté par un mainteneur (débloque ses PR)
+statut: à valider|fbca04|Ticket créé, en attente de validation
+statut: backlog|c5def5|Validé, pas encore commencé
+statut: en cours|1d76db|Travail commencé (PR en brouillon)
+statut: en relecture|5319e7|PR prête, en relecture
+statut: préprod|d93f0b|Mergé dans develop : en préversion de test
+statut: done|0e8a16|Publié en production
+type: feat|a2eeef|Nouvelle fonctionnalité (branche feat/…)
+type: fix|d73a4a|Correction de bug (branche fix/…)
+type: docs|0075ca|Documentation (branche docs/…)
+type: refactor|cfd3d7|Restructuration (branche refactor/…)
+type: chore|ededed|Maintenance (branche chore/…)
+ETIQUETTES
+
+# 2. Modèle de ticket et workflow (jamais écrasés)
+ecrire() { # $1 chemin ; contenu sur l'entrée standard
+    if [ -e "$1" ]; then
+        info_t tk.init_exists "$1"
+        cat >/dev/null
+    else
+        mkdir -p "$(dirname "$1")"
+        cat >"$1"
+        ok_t tk.init_written "$1"
+    fi
+}
+step_t tk.init_files
+ecrire .github/ISSUE_TEMPLATE/ticket.yml <<'YAML'
+name: Ticket
+description: Une tâche à réaliser (fonctionnalité, correction, maintenance)
+labels: ["statut: à valider"]
+body:
+  - type: textarea
+    id: besoin
+    attributes:
+      label: Besoin
+      description: Le problème à résoudre, pas seulement la solution imaginée
+    validations:
+      required: true
+  - type: textarea
+    id: termine
+    attributes:
+      label: Terminé quand…
+      description: Critères d'acceptation, vérifiables
+YAML
+ecrire .github/workflows/tickets.yml <<'YAML'
+# Suivi des tickets : le ticket d'abord, la branche en découle (créée à la
+# validation, liée au ticket), le premier push ouvre la PR en brouillon ;
+# statuts tenus à jour jusqu'à la production.
+name: tickets
+
+on:
+  pull_request_target:
+    types: [opened, reopened, edited, synchronize, ready_for_review, converted_to_draft, closed]
+  pull_request_review:
+    types: [submitted]
+  issues:
+    types: [opened, labeled, assigned, closed]
+  push:
+    branches-ignore: [main, master, develop]
+
+permissions: {}
+
+jobs:
+  tickets:
+    uses: SimBienvenueHoulBoumi/repowarden/.github/workflows/tickets.yml@v4
+    permissions: { contents: write, issues: write, pull-requests: write, statuses: write }
+YAML
+
+# 3. Tickets et branches existants (relançable : rien n'est fait deux fois)
+step_t tk.init_adopt
+GH_REPO="$REPO" AUTO_VALIDATE="${AUTO_VALIDATE:-maintainers}" "$ROOT/ci/tickets.sh" adopter | sed 's/^/  /'
+
+echo
+ok_t tk.init_done
+dim_t tk.init_next

package/hooks/commit-msg

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+# Hook commit-msg : impose le format Conventional Commits.
+# Ex : "feat(auth): ajoute la connexion JWT", "fix: corrige le calcul de TVA"
+set -euo pipefail
+
+source "$(dirname "$0")/lib/common.sh"
+exit_if_skipped
+run_local_hook "$@"
+
+MSG_FILE="$1"
+# Première ligne non commentée
+SUBJECT="$(grep -v '^#' "$MSG_FILE" | sed -n 1p)"
+
+# Commits générés par git : on laisse passer
+if [[ "$SUBJECT" =~ ^(Merge|Revert|fixup!|squash!) ]]; then
+    exit 0
+fi
+
+if ! [[ "$SUBJECT" =~ $CC_PATTERN ]]; then
+    if [ "${REPOWARDEN_LANG:-}" = en ]; then
+        cat >&2 <<EOF
+✖ Invalid commit message: "$SUBJECT"
+
+Expected format: <type>(<optional scope>): <description>
+  e.g.: feat(user): add sign-up
+        fix: fix the database timeout
+        refactor!: change the public API   (! = breaking change)
+
+Types:
+EOF
+        types_help
+        cat >&2 <<EOF
+
+👉 Tip: name your branch <type>/<topic> (e.g. feat/user) and the prefix
+   is added automatically: git commit -m "add sign-up"  (or use git cc)
+   Your message is not lost: git commit -e -F .git/COMMIT_EDITMSG
+EOF
+    else
+        cat >&2 <<EOF
+✖ Message de commit invalide : "$SUBJECT"
+
+Format attendu : <type>(<scope optionnel>): <description>
+  ex. : feat(user): ajoute l'inscription
+        fix: corrige le timeout de la base
+        refactor!: change l'API publique   (! = breaking change)
+
+Types :
+EOF
+        types_help
+        cat >&2 <<EOF
+
+👉 Astuce : nomme ta branche <type>/<sujet> (ex. feat/user) et le préfixe
+   sera ajouté automatiquement : git commit -m "ajoute l'inscription"  (ou git cc)
+   Ton message n'est pas perdu : git commit -e -F .git/COMMIT_EDITMSG
+EOF
+    fi
+    exit 1
+fi
+
+authored_length "$SUBJECT"
+if [ "$REPLY" -gt 72 ]; then
+    err_t hook.commit_msg.1 "$REPLY" >&2
+    exit 1
+fi

package/hooks/lang/actions.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+# Workflows GitHub Actions : actionlint au push / en CI
+register actions ".github/workflows" '^$'
+
+actions_test() {
+    has actionlint || { warn "GitHub Actions : actionlint absent, workflows non vérifiés."; return 0; }
+    step_t lang.actions.1
+    actionlint
+}

package/hooks/lang/ansible.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+# Ansible (playbooks, rôles, collections) : reformatage YAML par ansible-lint,
+# règles ansible-lint vérifiées au push / en CI.
+register ansible "ansible.cfg galaxy.yml requirements.yml .ansible-lint .ansible-lint.yml" '\.ya?ml$'
+
+ansible_format() {
+    has ansible-lint || { tool_missing "Ansible : ansible-lint absent, formatage ignoré."; return 0; }
+    step_t lang.ansible.1
+    # --fix=none : reformatage YAML seul ; les violations de règles sont
+    # signalées par ansible_test (push / CI), pas au commit.
+    ansible-lint -q --nocolor --fix=none "$@" >/dev/null 2>&1 || true
+}
+
+ansible_test() {
+    has ansible-lint || { warn "Ansible : ansible-lint absent, vérification ignorée."; return 0; }
+    step_t lang.ansible.2
+    ansible-lint -q --nocolor
+}

package/hooks/lang/cpp.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# C / C++ / Objective-C (CMake, Meson) : clang-format si .clang-format existe, ctest / meson test
+register cpp "CMakeLists.txt meson.build" '\.(c|h|cc|cpp|cxx|hh|hpp|hxx|m|mm)$' standalone outermost
+
+cpp_format() {
+    has clang-format || { tool_missing "C/C++ : clang-format absent, formatage ignoré."; return 0; }
+    find_up .clang-format >/dev/null || find_up _clang-format >/dev/null ||
+        { tool_missing "C/C++ : pas de .clang-format, formatage ignoré."; return 0; }
+    step_t lang.cpp.1; clang-format -i --style=file "$@"
+}
+
+cpp_test() {
+    # Recompile avant de tester : sinon les tests tournent sur l'ancien binaire
+    if [ -f build/CTestTestfile.cmake ] && has ctest; then
+        step_t lang.cpp.2
+        cmake --build build && ctest --test-dir build --output-on-failure
+    elif [ -f builddir/build.ninja ] && has meson; then
+        step_t lang.cpp.3; meson test -C builddir
+    else
+        info_t lang.cpp.4
+    fi
+}

package/hooks/lang/dart.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Dart / Flutter : dart format, flutter test / dart test
+register dart "pubspec.yaml" '\.dart$' standalone
+
+dart_format() {
+    has dart || { tool_missing "Dart : dart absent, formatage ignoré."; return 0; }
+    step_t lang.dart.1
+    dart format -o write "$@" >/dev/null
+}
+
+dart_test() {
+    [ -d test ] || { info "Dart : pas de dossier test/."; return 0; }
+    if grep -qs 'sdk: flutter' pubspec.yaml; then
+        has flutter || { warn "Flutter : flutter absent, tests ignorés."; return 0; }
+        step_t lang.dart.2; flutter test
+    else
+        has dart || { warn "Dart : dart absent, tests ignorés."; return 0; }
+        step_t lang.dart.3; dart test
+    fi
+}

package/hooks/lang/deno.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# Deno : deno fmt, deno test
+register deno "deno.json deno.jsonc" '\.(ts|tsx|js|jsx|json|jsonc|md)$'
+
+deno_format() {
+    has deno || { tool_missing "Deno : deno absent, formatage ignoré."; return 0; }
+    step_t lang.deno.1
+    deno fmt --quiet "$@"
+}
+
+deno_test() {
+    has deno || { warn "Deno : deno absent, tests ignorés."; return 0; }
+    step_t lang.deno.2
+    deno test --quiet
+}

package/hooks/lang/docker.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Docker : hadolint (Dockerfile), validation des fichiers Compose.
+register docker "Dockerfile Containerfile *.Dockerfile compose.yaml compose.yml docker-compose.yaml docker-compose.yml" '(^|/)(Dockerfile|Containerfile)[^/]*$|\.Dockerfile$'
+
+docker_test() {
+    local f
+    for f in Dockerfile* Containerfile *.Dockerfile; do
+        [ -f "$f" ] || continue
+        if has hadolint; then
+            step_t lang.docker.1 "$f"
+            hadolint "$f" || return 1
+        else
+            warn_t lang.docker.2 "$f"
+        fi
+    done
+    for f in compose.yaml compose.yml docker-compose.yaml docker-compose.yml; do
+        [ -f "$f" ] || continue
+        if docker compose version >/dev/null 2>&1; then
+            step_t lang.docker.3 "$f"
+            # --no-interpolate : pas d'échec sur les variables d'environnement absentes
+            docker compose -f "$f" config -q --no-interpolate || return 1
+        else
+            warn_t lang.docker.4 "$f"
+        fi
+    done
+}

package/hooks/lang/dotnet.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# .NET (ASP.NET, C#, F#) : dotnet format, dotnet test
+register dotnet "*.sln *.slnx *.csproj *.fsproj *.vbproj" '\.(cs|fs|vb)$' outermost
+
+dotnet_format() {
+    has dotnet || { tool_missing ".NET : dotnet absent, formatage ignoré."; return 0; }
+    step_t lang.dotnet.1
+    dotnet format --include "$@"
+}
+
+dotnet_test() {
+    has dotnet || { warn ".NET : dotnet absent, tests ignorés."; return 0; }
+    step_t lang.dotnet.2
+    dotnet test --nologo -v q
+}

package/hooks/lang/elixir.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# Elixir (Phoenix…) : mix format, mix test
+register elixir "mix.exs" '\.(ex|exs|heex)$'
+
+elixir_format() {
+    has mix || { tool_missing "Elixir : mix absent, formatage ignoré."; return 0; }
+    step_t lang.elixir.1; mix format "$@"
+}
+
+elixir_test() {
+    has mix || { warn "Elixir : mix absent, tests ignorés."; return 0; }
+    step_t lang.elixir.2; mix test
+}

package/hooks/lang/go.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# Go : gofmt, go test
+register go "go.mod" '\.go$' standalone
+
+go_format() {
+    has gofmt || { tool_missing "Go : gofmt absent, formatage ignoré."; return 0; }
+    step_t lang.go.1
+    gofmt -w "$@"
+}
+
+go_test() {
+    has go || { warn "Go : go absent, tests ignorés."; return 0; }
+    step_t lang.go.2
+    go test ./...
+}
+
+# Code mort prouvé : identifiants non exportés jamais utilisés (staticcheck U1000)
+go_deadcode() {
+    has staticcheck || { deadcode_tool_missing Go staticcheck; return 0; }
+    staticcheck -checks U1000 ./... 2>/dev/null |
+        sed -nE 's/^(.+):([0-9]+):[0-9]+: (.*) \(U1000\)$/prouve\t\1\t\2\t\3/p'
+}

package/hooks/lang/gradle.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Java / Kotlin / Gradle (Spring Boot, Android…) : Spotless si configuré
+# (fichiers stagés uniquement), gradle check
+register gradle "settings.gradle settings.gradle.kts build.gradle build.gradle.kts" '\.(java|kt|kts|groovy)$' outermost
+
+gradle_cmd() { if [ -x ./gradlew ]; then echo ./gradlew; else echo gradle; fi; }
+
+gradle_format() {
+    # Spotless peut être déclaré à la racine, dans un sous-projet ou dans buildSrc
+    find . -maxdepth 3 \( -name '*.gradle' -o -name '*.gradle.kts' \) -not -path '*/build/*' -print0 2>/dev/null |
+        xargs -0 grep -qs spotless ||
+        { tool_missing "Gradle : Spotless non configuré, formatage ignoré."; return 0; }
+    # Fichiers ciblés uniquement (chemins absolus, au format Windows si besoin :
+    # Gradle tourne sur Java) — plus rapide qu'un spotlessApply complet
+    local f files=""
+    for f in "$@"; do
+        f="$PWD/$f"
+        if has cygpath; then f="$(cygpath -m "$f")"; fi
+        files="${files:+$files,}$f"
+    done
+    step_t lang.gradle.1
+    "$(gradle_cmd)" -q spotlessApply -PspotlessIdeHook="$files"
+}
+
+gradle_test() { step "Gradle : $(gradle_cmd) check"; "$(gradle_cmd)" -q check; }
+
+# Code mort prouvé (PMD) : voir hooks/lib/deadcode.sh
+gradle_deadcode() { java_deadcode; }

package/hooks/lang/helm.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Helm : helm lint + rendu (helm template) + schémas (kubeconform) + helm unittest.
+# Les fichiers d'un chart sont des templates Go : JAMAIS de formatage YAML
+# (prettier les casserait) — d'où l'absence de helm_format.
+register helm "Chart.yaml" '\.(ya?ml|tpl|txt)$'
+
+helm_test() {
+    has helm || { warn "Helm : helm absent, vérification ignorée."; return 0; }
+    local rendered rc=0
+    if grep -qs '^dependencies:' Chart.yaml; then
+        step_t lang.helm.1
+        helm dependency build >/dev/null || return 1
+    fi
+    step_t lang.helm.2
+    helm lint --quiet . || return 1
+    rendered="$(mktemp)"
+    helm template repowarden . >"$rendered" || { rm -f "$rendered"; return 1; }
+    if has kubeconform; then
+        step_t lang.helm.3
+        kubeconform -strict -summary -ignore-missing-schemas -cache "$(kubeconform_cache)" <"$rendered" || rc=1
+    fi
+    rm -f "$rendered"
+    [ "$rc" = 0 ] || return 1
+    if [ -d tests ] && grep -q '^unittest' <<<"$(helm plugin list 2>/dev/null)"; then
+        step_t lang.helm.4
+        helm unittest .
+    fi
+}

package/hooks/lang/kubernetes.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# Kubernetes (kustomize) : prettier sur les manifestes, rendu kustomize +
+# validation des schémas (kubeconform, lu sur stdin : il ignore les fichiers
+# sans extension .yaml) au push / en CI.
+register kubernetes "kustomization.yaml kustomization.yml Kustomization" '\.ya?ml$'
+
+kubernetes_format() { node_format "$@"; }
+
+kubernetes_test() {
+    local rendered rc=0
+    rendered="$(mktemp)"
+    if has kubectl; then
+        step_t lang.kubernetes.1
+        kubectl kustomize . >"$rendered" || rc=1
+    elif has kustomize; then
+        step_t lang.kubernetes.2
+        kustomize build . >"$rendered" || rc=1
+    else
+        warn_t lang.kubernetes.3
+        rm -f "$rendered"
+        return 0
+    fi
+    if [ "$rc" = 0 ] && has kubeconform; then
+        step_t lang.kubernetes.4
+        kubeconform -strict -summary -ignore-missing-schemas -cache "$(kubeconform_cache)" <"$rendered" || rc=1
+    fi
+    rm -f "$rendered"
+    return "$rc"
+}

package/hooks/lang/maven.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Java / Maven (Spring Boot, Quarkus…) : Spotless si configuré, mvn verify
+register maven "pom.xml" '\.java$' outermost
+
+maven_cmd() { if [ -x ./mvnw ]; then echo ./mvnw; else echo mvn; fi; }
+
+maven_format() {
+    grep -q spotless pom.xml || { tool_missing "Maven : Spotless non configuré dans pom.xml, formatage ignoré."; return 0; }
+    step_t lang.maven.1
+    # Nom complet du plugin : pas de résolution du préfixe « spotless: » sur un
+    # index distant (un incident Maven Central faisait échouer le commit) ; la
+    # version utilisée reste celle déclarée dans le pom.xml.
+    "$(maven_cmd)" -q com.diffplug.spotless:spotless-maven-plugin:apply \
+        -DspotlessFiles="$(printf '%s\n' "$@" | spotless_files_regex)"
+}
+
+maven_test() { step "Maven : $(maven_cmd) verify"; "$(maven_cmd)" -q verify; }
+
+# Chemins relatifs (stdin) → liste de regex pour -DspotlessFiles.
+# Spotless compare au chemin absolu : ".*[\\/]src[\\/]A\.java" (/ ou \ pour Windows).
+# shellcheck disable=SC2016 # regex littérales
+spotless_files_regex() {
+    sed -e 's/[][\.*^$()+?{}|]/\\&/g' -e 's#/#[\\\\/]#g' -e 's#^#.*[\\\\/]#' | paste -sd, -
+}
+
+# Code mort prouvé (PMD) : voir hooks/lib/deadcode.sh
+maven_deadcode() { java_deadcode; }