repowarden 0.0.0-stage → 4.1.0

package/bin/npm-publication

@@ -0,0 +1,151 @@
+#!/usr/bin/env bash
+# Publication npm automatique d'un dépôt, mise en place en une commande :
+# chaque release publie le paquet (workflow npm-publish.yml), sans jeton : npm
+# vérifie que la publication vient de ce dépôt et de release.yml (publication
+# de confiance, OIDC) et joint la provenance au paquet.
+#
+#   bin/npm-publication [--repo propriétaire/nom] [--workflow release.yml]
+#                       [--environnement NOM]
+#
+# 1. connexion npm (npm login si besoin) ;
+# 2. paquet absent de npm (la publication de confiance exige un paquet
+#    existant) : jeton npm temporaire (7 jours, limité au scope du paquet)
+#    créé et rangé directement en secret NPM_TOKEN, sans être affiché ;
+#    variable REPOWARDEN_NPM=true ; la pipeline publie la dernière release
+#    (lancée par la commande), ou la prochaine s'il n'y en a pas encore ;
+# 3. publication de confiance (npm trust github), puis jeton révoqué et
+#    secret supprimé. Interrompue, la commande reprend où elle en était.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+# shellcheck source=../hooks/lib/common.sh
+source "$ROOT/hooks/lib/common.sh"
+
+REPO=""
+WORKFLOW="release.yml"
+ENVIRONMENT=""
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --repo) shift; REPO="${1:?--repo attend propriétaire/nom}" ;;
+        --workflow) shift; WORKFLOW="${1:?--workflow attend un fichier}" ;;
+        --environnement | --environment) shift; ENVIRONMENT="${1:?--environnement attend un nom}" ;;
+        -h | --help) sed -n '2,17p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+        *) err_t install.unknown_arg "$1"; exit 1 ;;
+    esac
+    shift
+done
+
+command -v gh >/dev/null || { err_t bot.no_gh; exit 1; }
+command -v npm >/dev/null || { err_t npm.no_npm; exit 1; }
+# npm trust : npm 11.15 au minimum
+if ! node -e 'const [a,b]=process.argv[1].split(".").map(Number);process.exit(a>11||(a==11&&b>=15)?0:1)' "$(npm --version)"; then
+    err_t npm.old_npm "$(npm --version)"
+    exit 1
+fi
+cd "$GIT_TOPLEVEL"
+[ -f package.json ] || { err_t npm.no_package; exit 1; }
+[ -n "$REPO" ] || REPO="$(gh repo view --json nameWithOwner -q .nameWithOwner)"
+name="$(node -p 'require("./package.json").name')"
+# Préfixe des jetons temporaires : nom unique à chaque création (npm refuse
+# les doublons, y compris celui d'une tentative interrompue) ; tous révoqués à la fin
+TOKEN_PREFIX="repowarden-ci-${REPO##*/}"
+
+brand "npm · $name · $REPO"
+
+# 1. Connexion npm : entre toi et npm (navigateur ou mot de passe)
+step_t npm.step_login
+npm whoami >/dev/null 2>&1 || npm login
+ok_t npm.logged "$(npm whoami)"
+# Créer un jeton et configurer la publication de confiance exigent la 2FA du
+# compte (les codes envoyés par e-mail ne sont qu'une vérification de connexion)
+if [ "$(npm profile get --json 2>/dev/null | node -e 'try{const p=JSON.parse(require("fs").readFileSync(0,"utf8"));process.stdout.write(p.tfa&&p.tfa.mode?"1":"")}catch{}')" != 1 ]; then
+    err_t npm.no_2fa
+    dim_t npm.hint_2fa "$(npm whoami)"
+    exit 1
+fi
+
+publie() { [ -n "$(npm view "$name" name 2>/dev/null || true)" ]; }
+
+# 2. Première publication, faite par la pipeline avec un jeton temporaire
+if ! publie; then
+    step_t npm.step_token
+    if grep -q '^NPM_TOKEN' <<<"$(gh secret list --repo "$REPO")"; then
+        ok_t npm.token_exists
+    else
+        # npm écrit ses questions et le jeton au même endroit : les questions
+        # sont posées ici (saisie masquée) et le jeton va droit au secret
+        if [[ "$name" == @*/* ]]; then portee=(--scopes "${name%%/*}"); else portee=(--packages-all); fi
+        t npm.ask_password
+        read -r -s -p "  $REPLY" mdp
+        echo
+        otp="" sortie=""
+        for essai in 1 2 3 4; do
+            # Sortie texte, pas --json : npm y masque le jeton (« npm_*** »)
+            if sortie="$(npm_config_password="$mdp" npm_config_otp="$otp" npm token create \
+                --name "$TOKEN_PREFIX-$(date +%Y%m%d%H%M%S)" --expires 7 "${portee[@]}" \
+                --packages-and-scopes-permission read-write --bypass-2fa </dev/null 2>&1)"; then
+                break
+            fi
+            # Code à usage unique (application ou e-mail) demandé : on le pose
+            if [ "$essai" -lt 4 ] && grep -qiE 'otp|one-time|two-factor' <<<"$sortie"; then
+                t npm.ask_otp
+                read -r -p "  $REPLY" otp
+                continue
+            fi
+            sed -E 's/npm_[A-Za-z0-9]+/npm_***/g' <<<"$sortie" >&2
+            mdp=""
+            err_t npm.token_failed
+            exit 1
+        done
+        mdp=""
+        jeton="$(grep -oE 'npm_[A-Za-z0-9]+' <<<"$sortie" | sed -n 1p || true)"
+        sortie=""
+        [ -n "$jeton" ] || { err_t npm.token_failed; exit 1; }
+        printf '%s' "$jeton" | gh secret set NPM_TOKEN --repo "$REPO"
+        jeton=""
+        ok_t npm.token_stored
+    fi
+    gh variable set REPOWARDEN_NPM --repo "$REPO" --body true
+
+    # Release déjà publiée : la pipeline est lancée tout de suite (elle publie
+    # la dernière release absente de npm) ; sinon, la prochaine release publie
+    if [ -n "$(git ls-remote --tags origin 'v[0-9]*')" ]; then
+        branche="$(gh repo view "$REPO" --json defaultBranchRef -q .defaultBranchRef.name)"
+        gh workflow run "$WORKFLOW" --repo "$REPO" --ref "$branche"
+        info_t npm.dispatched "$WORKFLOW"
+    else
+        info_t npm.waiting "$name"
+    fi
+    for i in $(seq 1 360); do
+        publie && break
+        [ $((i % 10)) -ne 0 ] || dim_t npm.still_waiting "$((i / 2))"
+        sleep 30
+    done
+    publie || { attention_t npm.not_yet; exit 0; }
+    ok_t npm.first_published "$name" "$(npm view "$name" version)"
+fi
+
+# 3. Publication de confiance, puis plus aucun jeton
+step_t npm.step_trust
+if grep -q '"id"' <<<"$(npm trust list "$name" --json 2>/dev/null || true)"; then
+    ok_t npm.trust_exists
+else
+    npm trust github "$name" --file "$WORKFLOW" --repo "$REPO" ${ENVIRONMENT:+--env "$ENVIRONMENT"} --allow-publish --yes
+    ok_t npm.trust_set "$REPO" "$WORKFLOW"
+fi
+gh variable set REPOWARDEN_NPM --repo "$REPO" --body true
+if grep -q '^NPM_TOKEN' <<<"$(gh secret list --repo "$REPO")"; then
+    gh secret delete NPM_TOKEN --repo "$REPO"
+    ok_t npm.token_removed
+fi
+# Jetons temporaires révoqués sur npm (retrouvés par leur préfixe). npm peut
+# demander un code 2FA : la commande garde le terminal (questions visibles)
+ids="$({ npm token list --json 2>/dev/null || true; } |
+    TOKEN_PREFIX="$TOKEN_PREFIX" node -e '
+        let l = []; try { l = JSON.parse(require("fs").readFileSync(0, "utf8")); } catch {}
+        const p = process.env.TOKEN_PREFIX;
+        for (const t of [].concat(l)) if (t && typeof t.name === "string" && (t.name === p || t.name.startsWith(p + "-"))) console.log(t.id || t.key);')"
+for id in $ids; do
+    npm token revoke "$id" && ok_t npm.token_revoked
+done
+ok_t npm.done "$name"

package/bin/proteger

@@ -0,0 +1,283 @@
+#!/usr/bin/env bash
+# Protège le dépôt GitHub courant d'après .repowarden.conf (relançable sans risque) :
+#   - branches protectedBranches : PR obligatoire, vérifications exigées à jour,
+#     ni suppression ni push forcé (ruleset « repowarden ») ;
+#   - merges : squash ; avec integrationBranch (flux develop), merge commit sur
+#     main et branche par défaut develop ; titre de PR = message du commit ;
+#   - tags v* : créés, déplacés ou supprimés uniquement par les workflows ;
+#   - GitHub Actions autorisé à créer des PR (releases automatiques) ;
+#   - validation humaine (optionnelle) : approbations obligatoires, revue des
+#     CODEOWNERS, environnement de déploiement approuvé par des personnes.
+#
+#   bin/proteger [--repo propriétaire/nom] [--checks "repowarden,tests (ubuntu-latest)"] [--relecteurs N]
+#                [--codeowners] [--environnement NOM] [--approbateurs "login …"]
+#                [--sans-tags] [--dry-run]
+# --sans-tags : dépôt qui déplace lui-même un tag (tag majeur flottant v2…).
+# Réglages équivalents dans .repowarden.conf (requiredReviews, codeOwnerReview,
+# environment, environmentReviewers). Demande un gh connecté, admin du dépôt.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+# shellcheck source=../hooks/lib/common.sh
+source "$ROOT/hooks/lib/common.sh"
+
+cfg_r requiredReviews 0
+REVIEWS="$REPLY"
+cfg_r codeOwnerReview false
+CODEOWNERS="$REPLY"
+cfg_r environment ""
+ENVIRONMENT="$REPLY"
+cfg_r environmentReviewers ""
+APPROVERS="$REPLY"
+REPO=""
+CHECKS="repowarden"
+DRY_RUN=""
+NO_TAGS=""
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --repo) shift; REPO="${1:?--repo attend propriétaire/nom}" ;;
+        --checks) shift; CHECKS="${1:?--checks attend une liste}" ;;
+        --relecteurs) shift; REVIEWS="${1:?--relecteurs attend un nombre}" ;;
+        --codeowners) CODEOWNERS=true ;;
+        --environnement) shift; ENVIRONMENT="${1:?--environnement attend un nom}" ;;
+        --approbateurs) shift; APPROVERS="${1:?--approbateurs attend des logins}" ;;
+        --sans-tags) NO_TAGS=1 ;;
+        --dry-run) DRY_RUN=1 ;;
+        -h | --help) sed -n '2,18p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+        *) err_t install.unknown_arg "$1"; exit 1 ;;
+    esac
+    shift
+done
+[ -n "$REPO" ] || REPO="$(gh repo view --json nameWithOwner -q .nameWithOwner)"
+[[ "$REVIEWS" =~ ^[0-9]$ ]] || { err_t ci.proteger.reviews_invalid; exit 1; }
+[[ "$CODEOWNERS" =~ ^(true|false)$ ]] || { err_t ci.proteger.codeowners_invalid; exit 1; }
+# Avec relecture : le dernier à pousser ne peut pas approuver son propre push
+last_push=false
+[ "$REVIEWS" = 0 ] || last_push=true
+
+cfg_r protectedBranches "main master"
+protected="$REPLY"
+cfg_r integrationBranch ""
+integration="$REPLY"
+
+# Branches protégées existant sur GitHub (main ou master selon le dépôt)
+existing=""
+for b in $protected; do
+    # Nom renvoyé comparé : GitHub redirige une branche renommée (master → main)
+    [ "$(gh api "repos/$REPO/branches/$b" --jq .name 2>/dev/null)" = "$b" ] && existing="$existing $b"
+done
+[ -n "$existing" ] || { err_t ci.proteger.no_branch "$protected" "$REPO"; exit 1; }
+
+# Vérifications séparées par des virgules : un nom de job peut contenir des
+# espaces (« tests (ubuntu-latest) »)
+contexts=""
+IFS=, read -ra checks <<<"$CHECKS"
+for c in "${checks[@]}"; do
+    c="${c#"${c%%[![:space:]]*}"}"
+    c="${c%"${c##*[![:space:]]}"}"
+    [ -n "$c" ] && contexts="$contexts {\"context\": \"$c\", \"integration_id\": 15368},"
+done
+contexts="${contexts%,}"
+
+refs_json() { # branches → "refs/heads/a", "refs/heads/b"
+    local b out=""
+    for b in "$@"; do out="$out \"refs/heads/$b\","; done
+    echo "${out%,}"
+}
+
+# Ruleset de branches : $1 nom, $2 branches (liste), $3 méthodes de merge (JSON),
+# $4 PR à jour exigée (défaut true), $5 approbations (défaut REVIEWS),
+# $6 dernier push approuvé par un autre (défaut selon REVIEWS)
+branch_ruleset() {
+    # shellcheck disable=SC2086 # liste de branches volontairement découpée
+    cat <<JSON
+{
+  "name": "$1",
+  "target": "branch",
+  "enforcement": "active",
+  "bypass_actors": [],
+  "conditions": {"ref_name": {"include": [$(refs_json $2)], "exclude": []}},
+  "rules": [
+    {"type": "deletion"},
+    {"type": "non_fast_forward"},
+    {"type": "pull_request", "parameters": {
+      "allowed_merge_methods": [$3],
+      "dismiss_stale_reviews_on_push": true,
+      "require_code_owner_review": $CODEOWNERS,
+      "require_last_push_approval": ${6:-$last_push},
+      "required_approving_review_count": ${5:-$REVIEWS},
+      "required_review_thread_resolution": true}},
+    {"type": "required_status_checks", "parameters": {
+      "strict_required_status_checks_policy": ${4:-true},
+      "do_not_enforce_on_create": false,
+      "required_status_checks": [$contexts]}}
+  ]
+}
+JSON
+}
+
+# Tags de version v*. Organisation : posés uniquement par les workflows
+# (GitHub Actions en exception). Compte personnel : GitHub n'accepte pas
+# cette exception ; un tag publié ne peut alors être ni déplacé ni supprimé
+# (exception : administrateurs, tracée), sa création restant libre.
+tags_ruleset() { # $1 : Organization ou User
+    local bypass rules
+    if [ "$1" = Organization ]; then
+        bypass='{"actor_id": 15368, "actor_type": "Integration", "bypass_mode": "always"}'
+        rules='{"type": "creation"}, {"type": "update"}, {"type": "deletion"}'
+    else
+        bypass='{"actor_id": 5, "actor_type": "RepositoryRole", "bypass_mode": "always"}'
+        rules='{"type": "update"}, {"type": "deletion"}'
+    fi
+    cat <<JSON
+{
+  "name": "repowarden (tags)",
+  "target": "tag",
+  "enforcement": "active",
+  "bypass_actors": [$bypass],
+  "conditions": {"ref_name": {"include": ["refs/tags/v*"], "exclude": []}},
+  "rules": [$rules]
+}
+JSON
+}
+
+rulesets=()
+if [ -n "$integration" ]; then
+    # main : livraisons (develop, release/…, hotfix/…) en merge commit, pour
+    # garder le détail des commits dans l'historique et les notes de version ;
+    # develop : travail en squash, merge commit pour release/… et hotfix/…
+    others=""
+    for b in $existing; do [ "$b" = "$integration" ] || others="$others $b"; done
+    # Livraison vers main = passage à une nouvelle version : approbation
+    # humaine obligatoire (la PR de livraison est ouverte par le workflow,
+    # le mainteneur peut donc l'approuver), sans exiger un autre approbateur
+    # que l'auteur du dernier push sauf si des relectures sont configurées
+    livraison=$((REVIEWS > 0 ? REVIEWS : 1))
+    # PR à jour non exigée non plus : le merge commit d'une livraison n'existe
+    # que sur main ; strict, la livraison suivante serait bloquée tant que
+    # develop ne l'a pas reçu (retour main → develop vide après chaque
+    # release). Une livraison n'apporte que develop, vérifiée par la CI ; le
+    # retour reste fait quand main a un contenu propre (correctif direct).
+    [ -z "$others" ] || rulesets+=("$(branch_ruleset repowarden "$others" '"merge"' false "$livraison" "$last_push")")
+    # Branche d'intégration : PR à jour non exigée. Le retour de main (après
+    # une release) serait sinon presque toujours en retard, et « mettre à jour »
+    # fusionnerait develop dans main en contournant la livraison ; la CI
+    # vérifie de toute façon chaque push sur develop.
+    [[ " $existing " != *" $integration "* ]] ||
+        rulesets+=("$(branch_ruleset "repowarden ($integration)" "$integration" '"squash", "merge"' false)")
+    merge_commit=true
+    # Nettoyage par le workflow nettoyage-branches (garde une branche encore
+    # source d'une autre PR ouverte)
+    delete_on_merge=false
+    # Merge automatique désactivé : aucune livraison programmée sans décision
+    auto_merge=false
+    # Sans ce workflow, les branches mergées ne seraient plus supprimées
+    if ! grep -qs "nettoyage-branches.yml" "$GIT_TOPLEVEL"/.github/workflows/*.y*ml; then
+        attention_t ci.proteger.no_cleanup
+    fi
+    t ci.proteger.methods_flow "$integration"
+    methods="$REPLY"
+else
+    rulesets+=("$(branch_ruleset repowarden "$existing" '"squash"')")
+    merge_commit=false
+    auto_merge=true
+    delete_on_merge=true
+    methods="squash"
+fi
+owner_type="$(gh api "repos/$REPO" --jq .owner.type)"
+if [ -z "$NO_TAGS" ]; then
+    rulesets+=("$(tags_ruleset "$owner_type")")
+    if [ "$owner_type" = Organization ]; then
+        t ci.proteger.tags_org
+        tags_msg="$REPLY"
+    else
+        t ci.proteger.tags_user
+        tags_msg="$REPLY"
+    fi
+else
+    t ci.proteger.tags_none
+    tags_msg="$REPLY"
+fi
+
+echo_t ci.proteger.1 "$REPO"
+echo_t ci.proteger.2 "$existing"
+echo_t ci.proteger.3 "$CHECKS"
+echo_t ci.proteger.4 "$methods" "$delete_on_merge"
+[ -z "$integration" ] || echo_t ci.proteger.delivery "$livraison"
+echo_t ci.proteger.5 "$tags_msg"
+[ -z "$integration" ] || echo_t ci.proteger.6 "$integration"
+echo_t ci.proteger.7 "$REVIEWS" "$CODEOWNERS"
+if [ "$REVIEWS" != 0 ] || [ "$CODEOWNERS" = true ]; then
+    echo_t ci.proteger.8
+fi
+
+# Environnement de déploiement : chaque job « environment: NOM » attend
+# l'approbation d'une des personnes désignées ; déploiement seulement depuis
+# les branches protégées et les tags v*
+env_json=""
+if [ -n "$ENVIRONMENT" ]; then
+    [ -n "$APPROVERS" ] || APPROVERS="$(gh api user --jq .login)"
+    reviewers=""
+    # Personnes (login) ou équipes (@organisation/equipe : membres gérés dans GitHub)
+    for login in $APPROVERS; do
+        case "$login" in
+            */*)
+                team="${login#@}"
+                id="$(gh api "orgs/${team%%/*}/teams/${team#*/}" --jq .id)" ||
+                    { err_t ci.proteger.unknown_team "$login"; exit 1; }
+                reviewers="$reviewers {\"type\": \"Team\", \"id\": $id},"
+                ;;
+            *)
+                id="$(gh api "users/${login#@}" --jq .id)" || { err_t ci.proteger.unknown_user "$login"; exit 1; }
+                reviewers="$reviewers {\"type\": \"User\", \"id\": $id},"
+                ;;
+        esac
+    done
+    # Seul approbateur = soi-même (projet solo) : l'auto-approbation reste permise
+    self_review=true
+    [ "$(wc -w <<<"$APPROVERS")" -gt 1 ] || self_review=false
+    env_json="{\"reviewers\": [${reviewers%,}], \"prevent_self_review\": $self_review,
+  \"deployment_branch_policy\": {\"protected_branches\": false, \"custom_branch_policies\": true}}"
+    echo_t ci.proteger.9 "$ENVIRONMENT" "$APPROVERS"
+fi
+if [ -n "$DRY_RUN" ]; then
+    printf '%s\n' "${rulesets[@]}"
+    [ -z "$env_json" ] || printf '%s\n' "$env_json"
+    exit 0
+fi
+
+settings=(-F allow_squash_merge=true -F allow_merge_commit="$merge_commit" -F allow_rebase_merge=false
+    -F delete_branch_on_merge="$delete_on_merge" -F allow_auto_merge="$auto_merge"
+    -f squash_merge_commit_title=PR_TITLE -f squash_merge_commit_message=PR_BODY)
+[ -z "$integration" ] || settings+=(-f default_branch="$integration")
+gh api -X PATCH "repos/$REPO" --silent "${settings[@]}"
+gh api -X PUT "repos/$REPO/actions/permissions/workflow" --silent \
+    -f default_workflow_permissions=read -F can_approve_pull_request_reviews=true
+
+for ruleset in "${rulesets[@]}"; do
+    name="$(sed -n 's/^  "name": "\(.*\)",$/\1/p' <<<"$ruleset")"
+    # Ruleset posé sous l'ancien nom (repogarde, v3) : repris et renommé, sinon
+    # il resterait à côté et exigerait une vérification « repogarde » disparue
+    old="${name/repowarden/repogarde}"
+    id="$(gh api "repos/$REPO/rulesets" \
+        --jq "([.[] | select(.name == \"$name\")] + [.[] | select(.name == \"$old\")]) | .[0].id // empty")"
+    if [ -n "$id" ]; then
+        gh api -X PUT "repos/$REPO/rulesets/$id" --input - <<<"$ruleset" >/dev/null
+        ok_t ci.proteger.10 "$name"
+    else
+        gh api -X POST "repos/$REPO/rulesets" --input - <<<"$ruleset" >/dev/null
+        ok_t ci.proteger.11 "$name"
+    fi
+done
+if [ -n "$env_json" ]; then
+    gh api -X PUT "repos/$REPO/environments/$ENVIRONMENT" --input - --silent <<<"$env_json"
+    policies="$(gh api "repos/$REPO/environments/$ENVIRONMENT/deployment-branch-policies" \
+        --jq '.branch_policies[] | "\(.type):\(.name)"')"
+    for policy in $(for b in $existing; do echo "branch:$b"; done) "tag:v*"; do
+        grep -qxF "$policy" <<<"$policies" && continue
+        gh api -X POST "repos/$REPO/environments/$ENVIRONMENT/deployment-branch-policies" --silent \
+            -f type="${policy%%:*}" -f name="${policy#*:}"
+    done
+    ok_t ci.proteger.12 "$ENVIRONMENT"
+fi
+ok_t ci.proteger.13

package/bin/repogarde

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Ancien nom de la commande (repogarde, jusqu'à la v3) : relaie vers repowarden
+# avec un avertissement. Retiré en v5.
+set -euo pipefail
+
+# Dossier réel du paquet : npm appelle ce script via un lien symbolique
+src="${BASH_SOURCE[0]}"
+while [ -L "$src" ]; do
+    dir="$(cd "$(dirname "$src")" && pwd -P)"
+    src="$(readlink "$src")"
+    case "$src" in /*) ;; *) src="$dir/$src" ;; esac
+done
+ROOT="$(cd "$(dirname "$src")/.." && pwd -P)"
+# shellcheck source=../hooks/lib/ui.sh
+source "$ROOT/hooks/lib/ui.sh"
+# shellcheck source=../hooks/lib/i18n.sh
+source "$ROOT/hooks/lib/i18n.sh"
+
+attention_t compat.old_command
+exec bash "$ROOT/bin/repowarden" "$@"

package/bin/repowarden

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# Point d'entrée unique de repowarden (paquet npm, ou clone du dépôt) :
+#   repowarden                                     état du poste et étape suivante
+#   repowarden statut                              (idem)
+#   repowarden install [--global] [--lang fr|en]   active les hooks (install.sh)
+#   repowarden uninstall [--global] [--purge]      les retire (avant npm uninstall -g)
+#   repowarden cc                                  assistant de commit
+#   repowarden code-mort                           nouveau code mort de la branche
+#   repowarden ticket <n>                         branche du ticket (créée, liée, si besoin)
+#   repowarden ticket nouveau "<titre>"           nouveau ticket
+#   repowarden tickets init                        suivi des tickets (GitHub)
+#   repowarden proteger [options]                  protection des branches (GitHub)
+#   repowarden npm-publication                     publication npm automatique
+#   repowarden --version
+set -euo pipefail
+
+# Dossier réel du paquet : npm appelle ce script via un lien symbolique
+# (node_modules/.bin, préfixe global) ; readlink -f absent de macOS
+src="${BASH_SOURCE[0]}"
+while [ -L "$src" ]; do
+    dir="$(cd "$(dirname "$src")" && pwd -P)"
+    src="$(readlink "$src")"
+    case "$src" in /*) ;; *) src="$dir/$src" ;; esac
+done
+ROOT="$(cd "$(dirname "$src")/.." && pwd -P)"
+# shellcheck source=../hooks/lib/ui.sh
+source "$ROOT/hooks/lib/ui.sh"
+# shellcheck source=../hooks/lib/i18n.sh
+source "$ROOT/hooks/lib/i18n.sh"
+
+aide() { sed -n '2,14p' "$ROOT/bin/repowarden" | sed 's/^# \{0,1\}//'; }
+
+commande="${1:-}"
+[ $# -eq 0 ] || shift
+case "$commande" in
+    install)
+        # npx : paquet dans un cache temporaire, effaçable à tout moment ;
+        # des hooks globaux y pointeraient vers un dossier disparu
+        if [[ " $* " == *" --global "* && "$ROOT" == */_npx/* ]]; then
+            err_t npm.npx_global
+            exit 1
+        fi
+        exec bash "$ROOT/install.sh" "$@"
+        ;;
+    uninstall) exec bash "$ROOT/install.sh" --uninstall "$@" ;;
+    cc | commit) exec bash "$ROOT/bin/commit" "$@" ;;
+    code-mort | deadcode) exec bash "$ROOT/bin/code-mort" "$@" ;;
+    tickets) exec bash "$ROOT/bin/tickets" "$@" ;;
+    ticket) exec bash "$ROOT/bin/ticket" "$@" ;;
+    proteger | protect) exec bash "$ROOT/bin/proteger" "$@" ;;
+    npm-publication | npm-publish) exec bash "$ROOT/bin/npm-publication" "$@" ;;
+    -v | --version | version)
+        repowarden_version_r "$ROOT"
+        echo "$REPLY"
+        ;;
+    "" | statut | status) exec bash "$ROOT/bin/statut" "$@" ;;
+    -h | --help | help) aide ;;
+    *)
+        err_t install.unknown_arg "$commande"
+        aide >&2
+        exit 1
+        ;;
+esac

package/bin/statut

@@ -0,0 +1,100 @@
+#!/usr/bin/env bash
+# État de repowarden sur ce poste et dans le dépôt courant, puis la commande
+# suivante à lancer (l'équivalent de « gh auth status » ou « brew doctor ») :
+#   repowarden statut        (ou repowarden, sans argument)
+# Lecture seule : rien n'est modifié.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+# shellcheck source=../hooks/lib/common.sh
+source "$ROOT/hooks/lib/common.sh"
+exec 2>&1 # une seule sortie, dans l'ordre (avertissements compris)
+# shellcheck disable=SC2034 # lu par check_version (common.sh)
+HOOKS_DIR="$ROOT/hooks"
+
+repowarden_version_r "$ROOT"
+version="$REPLY"
+case "$ROOT" in
+    */node_modules/*) mode=npm ;;
+    *) mode=clone ;;
+esac
+suivant="" # première action à faire, affichée à la fin
+
+reel() { [ -d "$1" ] && (cd "$1" && pwd -P); }
+
+brand "${version:-?} · $mode · $ROOT"
+
+# Hooks globaux : ceux de cette installation, d'une autre, ou d'un autre outil
+global="$(git config --global --get core.hooksPath 2>/dev/null || true)"
+local_hooks="$(git config --local --get core.hooksPath 2>/dev/null || true)"
+if [ -z "$global" ] && [ -n "$local_hooks" ] && [ "$(reel "$local_hooks")" = "$ROOT/hooks" ]; then
+    # Installation locale (install.sh sans --global) : active dans ce dépôt
+    ok_t st.hooks_repo
+elif [ -z "$global" ]; then
+    err_t st.hooks_off
+    suivant="${suivant:-repowarden install --global}"
+elif [ "$(reel "$global")" = "$ROOT/hooks" ]; then
+    ok_t st.hooks_on
+elif [ -f "$global/lib/common.sh" ] && grep -qsE "repowarden|repogarde" "$global/lib/common.sh"; then
+    attention_t st.hooks_other "$global"
+    suivant="${suivant:-repowarden install --global}"
+else
+    info_t st.hooks_foreign "$global"
+fi
+
+# Assistant de commit (git cc) : valeur effective, installation locale comprise
+alias_cc="$(git config --get alias.cc 2>/dev/null || true)"
+if [[ "$alias_cc" == *"$ROOT/bin/commit"* ]]; then
+    ok_t st.cc_on
+elif [[ "$alias_cc" == *"/bin/commit"* ]]; then
+    attention_t st.cc_other
+    suivant="${suivant:-repowarden install --global}"
+elif [ -n "$alias_cc" ]; then
+    info_t st.cc_foreign "$alias_cc"
+else
+    err_t st.cc_off
+    suivant="${suivant:-repowarden install --global}"
+fi
+
+info_t st.lang "$REPOWARDEN_LANG"
+
+# Dépôt courant
+if [ -n "$GIT_TOPLEVEL" ]; then
+    step_t st.repo "$GIT_TOPLEVEL"
+    local_path="$(git config --local --get core.hooksPath 2>/dev/null || true)"
+    if [ -n "$local_path" ]; then
+        info_t st.repo_local "$local_path"
+    fi
+    for f in lefthook.yml lefthook.yaml .lefthook.yml .lefthook.yaml; do
+        [ -f "$GIT_TOPLEVEL/$f" ] || continue
+        attention_t st.repo_lefthook "$f"
+        break
+    done
+    cfg_r version ""
+    if [ -n "$REPLY" ]; then
+        attendue="${REPLY#v}"
+        if [ -n "$(check_version 2>&1)" ]; then
+            attention_t st.repo_version_old "$attendue" "${version:-?}"
+            [ "$mode" = npm ] && suivant="${suivant:-npm update -g repowarden}"
+        else
+            ok_t st.repo_version_ok "$attendue"
+        fi
+    fi
+    info_t st.repo_forge "$FORGE"
+fi
+
+# Outils : secrets, code mort (selon les langages)
+presents="" absents=""
+for outil in gitleaks ruff vulture staticcheck pmd; do
+    if has "$outil"; then presents="$presents $outil"; else absents="$absents $outil"; fi
+done
+info_t st.tools "${presents# }" "${absents# }"
+
+echo
+if [ -n "$suivant" ]; then
+    t st.next
+    printf '%s %s%s%s\n' "$REPLY" "$UI_B" "$suivant" "$UI_N"
+else
+    ok_t st.ready
+fi
+dim_t st.help