devzone 0.0.0-stage → 0.5.0

package/.devcontainer/Dockerfile

@@ -0,0 +1,72 @@
+# Image de base de devzone : outils sans feature officielle, versions figées.
+# Java, Node, Python, Docker, kubectl, helm et gh sont ajoutés par les features
+# de devcontainer.json, par-dessus cette image.
+
+# uv : binaire de l'image officielle (pas de script curl | sh)
+ARG UV_VERSION=0.13.1
+FROM ghcr.io/astral-sh/uv:${UV_VERSION} AS uv
+
+FROM mcr.microsoft.com/devcontainers/base:ubuntu-24.04
+
+# Versions : pour mettre à jour, changer la version ET l'empreinte sha256,
+# puis Rebuild Container
+ARG K9S_VERSION=0.51.0
+ARG ACTIONLINT_VERSION=1.7.12
+ARG GITLEAKS_VERSION=8.30.1
+ARG KIND_VERSION=0.33.0
+ARG RUFF_VERSION=0.17.0
+ARG VULTURE_VERSION=2.16
+# pytest : même version que la CI de repowarden (ci/requirements/e2e-python.in)
+ARG PYTEST_VERSION=9.1.1
+
+SHELL ["/bin/bash", "-o", "pipefail", "-c"]
+
+# Contrôles shell de repowarden
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends shellcheck bats \
+    && rm -rf /var/lib/apt/lists/*
+
+# k9s, actionlint (mêmes versions que la CI de repowarden), gitleaks, kind :
+# installer <nom> <url> <sha256> : empreinte vérifiée avant d'installer quoi que ce soit dans /usr/local/bin
+# (kind est un binaire seul, sans archive : installé à part, même vérification)
+RUN set -eu; \
+    arch="$(dpkg --print-architecture)"; \
+    case "$arch" in \
+        arm64) gl_arch=arm64; \
+               k9s_sha=3ee05c82e5f9198928a4e86133608ba6a2c10a2244d6a7789e820f78319d640c; \
+               al_sha=325e971b6ba9bfa504672e29be93c24981eeb1c07576d730e9f7c8805afff0c6; \
+               gl_sha=e4a487ee7ccd7d3a7f7ec08657610aa3606637dab924210b3aee62570fb4b080; \
+               kind_sha=20022bee6cfcd5086cb7234d218e3454e6090022f2a8f55d1fa7fcf42c3867a2 ;; \
+        amd64) gl_arch=x64; \
+               k9s_sha=c3752ad51a5a4015a113819c4eeb6e55a4d0e4b8e652494797532f6fc8161dd7; \
+               al_sha=8aca8db96f1b94770f1b0d72b6dddcb1ebb8123cb3712530b08cc387b349a3d8; \
+               gl_sha=551f6fc83ea457d62a0d98237cbad105af8d557003051f41f3e7ca7b3f2470eb; \
+               kind_sha=aee6151561422756b764a4ae28e7f44cda5af5a9eead3cc9985112b1de8d8e0d ;; \
+        *) echo "Architecture non prise en charge : $arch" >&2; exit 1 ;; \
+    esac; \
+    installer() { \
+        tmp="$(mktemp -d)"; \
+        curl -fsSL "$2" -o "$tmp/a.tar.gz"; \
+        echo "$3  $tmp/a.tar.gz" | sha256sum -c --quiet; \
+        tar -xzf "$tmp/a.tar.gz" -C "$tmp" "$1"; \
+        install -m 0755 "$tmp/$1" /usr/local/bin/"$1"; \
+        rm -rf "$tmp"; \
+    }; \
+    installer k9s "https://github.com/derailed/k9s/releases/download/v${K9S_VERSION}/k9s_Linux_${arch}.tar.gz" "$k9s_sha"; \
+    installer actionlint "https://github.com/rhysd/actionlint/releases/download/v${ACTIONLINT_VERSION}/actionlint_${ACTIONLINT_VERSION}_linux_${arch}.tar.gz" "$al_sha"; \
+    installer gitleaks "https://github.com/gitleaks/gitleaks/releases/download/v${GITLEAKS_VERSION}/gitleaks_${GITLEAKS_VERSION}_linux_${gl_arch}.tar.gz" "$gl_sha"; \
+    curl -fsSL "https://github.com/kubernetes-sigs/kind/releases/download/v${KIND_VERSION}/kind-linux-${arch}" -o /tmp/kind; \
+    echo "$kind_sha  /tmp/kind" | sha256sum -c --quiet; \
+    install -m 0755 /tmp/kind /usr/local/bin/kind; \
+    rm -f /tmp/kind
+
+COPY --from=uv /uv /uvx /usr/local/bin/
+
+# ruff, vulture (repowarden code-mort a besoin des deux) et pytest, installés pour
+# tous les utilisateurs, avec un Python géré par uv hors du home
+# (variables limitées au build : uv tool install reste dans ~/.local pour vscode)
+RUN export UV_TOOL_DIR=/opt/uv/tools UV_TOOL_BIN_DIR=/usr/local/bin \
+        UV_PYTHON_INSTALL_DIR=/opt/uv/python \
+    && uv tool install "ruff==${RUFF_VERSION}" \
+    && uv tool install "vulture==${VULTURE_VERSION}" \
+    && uv tool install "pytest==${PYTEST_VERSION}"

package/.devcontainer/demarrage.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# À chaque démarrage, dans l'ordre : identité git (déduite du compte gh),
+# clusters Kubernetes, puis récapitulatif de ce qui reste à faire (devzone).
+# Séquentiel : le récapitulatif voit l'identité tout juste posée ; l'échec
+# d'une étape n'empêche pas les suivantes.
+ICI="$(dirname "$0")"
+bash "$ICI/git-identite.sh" || echo "démarrage : identité git non traitée (bash $ICI/git-identite.sh)"
+bash "$ICI/kube-config.sh" || echo "démarrage : clusters non traités (bash $ICI/kube-config.sh)"
+echo
+bash "$ICI/devzone"

package/.devcontainer/devcontainer-lock.json

@@ -0,0 +1,34 @@
+{
+  "features": {
+    "ghcr.io/devcontainers/features/docker-in-docker:2": {
+      "version": "2.17.0",
+      "resolved": "ghcr.io/devcontainers/features/docker-in-docker@sha256:25b9f05705ffba7dbe503230ac76081419306f8c8bc88e0ce78c4ecd99a0c78c",
+      "integrity": "sha256:25b9f05705ffba7dbe503230ac76081419306f8c8bc88e0ce78c4ecd99a0c78c"
+    },
+    "ghcr.io/devcontainers/features/github-cli:1": {
+      "version": "1.1.3",
+      "resolved": "ghcr.io/devcontainers/features/github-cli@sha256:bd7ab48a832228f633239277552c30b353867fef2e5b037e064b4e64f0b843f2",
+      "integrity": "sha256:bd7ab48a832228f633239277552c30b353867fef2e5b037e064b4e64f0b843f2"
+    },
+    "ghcr.io/devcontainers/features/java:1": {
+      "version": "1.8.3",
+      "resolved": "ghcr.io/devcontainers/features/java@sha256:61a839211feda1e2a1f10646648a948e733e4d98d770f3a4b6698a3c5fc92abe",
+      "integrity": "sha256:61a839211feda1e2a1f10646648a948e733e4d98d770f3a4b6698a3c5fc92abe"
+    },
+    "ghcr.io/devcontainers/features/kubectl-helm-minikube:1": {
+      "version": "1.3.1",
+      "resolved": "ghcr.io/devcontainers/features/kubectl-helm-minikube@sha256:bbe8adf6b37fff8c67412ab0a4579f4c2f30bbaba1d9a5cebd9e38bade54025b",
+      "integrity": "sha256:bbe8adf6b37fff8c67412ab0a4579f4c2f30bbaba1d9a5cebd9e38bade54025b"
+    },
+    "ghcr.io/devcontainers/features/node:1": {
+      "version": "1.7.1",
+      "resolved": "ghcr.io/devcontainers/features/node@sha256:8c0de46939b61958041700ee89e3493f3b2e4131a06dc46b4d9423427d06e5f6",
+      "integrity": "sha256:8c0de46939b61958041700ee89e3493f3b2e4131a06dc46b4d9423427d06e5f6"
+    },
+    "ghcr.io/devcontainers/features/python:1": {
+      "version": "1.8.0",
+      "resolved": "ghcr.io/devcontainers/features/python@sha256:fbcad6955caeecc5ad3f7886baf652e25cba5225a6c4c2287c536de2e5607511",
+      "integrity": "sha256:fbcad6955caeecc5ad3f7886baf652e25cba5225a6c4c2287c536de2e5607511"
+    }
+  }
+}

package/.devcontainer/devcontainer.json

@@ -0,0 +1,91 @@
+{
+  "name": "devzone",
+  // Image de base + outils figés (k9s, uv, actionlint, gitleaks…) : voir Dockerfile
+  "build": { "dockerfile": "Dockerfile" },
+
+  "features": {
+    "ghcr.io/devcontainers/features/java:1": {
+      "version": "21",
+      "jdkDistro": "tem",
+      "installMaven": true
+    },
+    "ghcr.io/devcontainers/features/node:1": {
+      "version": "lts",
+      "pnpmVersion": "latest"
+    },
+    "ghcr.io/devcontainers/features/python:1": {
+      "version": "3.12",
+      // Pas d'outils pipx : leur lanceur « python -E » ignore PYTHONPATH et
+      // PYTHONPYCACHEPREFIX, dont repowarden a besoin pour lancer les tests
+      // (ruff, vulture et pytest viennent du Dockerfile, par uv)
+      "installTools": false
+    },
+    "ghcr.io/devcontainers/features/docker-in-docker:2": {},
+    "ghcr.io/devcontainers/features/kubectl-helm-minikube:1": {
+      "minikube": "none"
+    },
+    // gh : tickets, PR, protection (repowarden)
+    "ghcr.io/devcontainers/features/github-cli:1": {}
+  },
+
+  // Toujours /workspaces/devzone, quel que soit le nom du dossier sur l'hôte
+  // (npx devzone <dossier>) : scripts et chemins du conteneur en dépendent
+  "workspaceMount": "source=${localWorkspaceFolder},target=/workspaces/devzone,type=bind,consistency=cached",
+  "workspaceFolder": "/workspaces/devzone",
+
+  // Caches persistants : survivent aux rebuilds du conteneur. Préfixe des
+  // volumes : devzone, ou DEVZONE_VOLUMES (tests fonctionnels, isolés)
+  "mounts": [
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-m2,target=/home/vscode/.m2,type=volume",
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-pnpm,target=/home/vscode/.local/share/pnpm,type=volume",
+    // Assistants IA : connexion et réglages gardés d'un rebuild à l'autre
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-claude,target=/home/vscode/.claude,type=volume",
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-opencode-config,target=/home/vscode/.config/opencode,type=volume",
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-opencode-data,target=/home/vscode/.local/share/opencode,type=volume",
+    // Connexion gh et identité git (~/.config/git/config, lu par git comme
+    // config globale) : le conteneur reconstruit peut commiter et pousser
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-gh,target=/home/vscode/.config/gh,type=volume",
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-git,target=/home/vscode/.config/git,type=volume",
+    // Modules activés (devzone activer|desactiver), propres à chaque utilisateur
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-config,target=/home/vscode/.config/devzone,type=volume"
+  ],
+
+  "runArgs": [
+    // Cluster Kubernetes de l'hôte : sa config en lecture seule, adaptée au
+    // conteneur par kube-config.sh. HOME (Mac, Linux) ou USERPROFILE (Windows) ;
+    // -v plutôt que mounts : crée ~/.kube s'il manque au lieu d'échouer
+    "-v", "${localEnv:HOME}${localEnv:USERPROFILE}/.kube:/home/vscode/.kube-host:ro",
+    // host.docker.internal existe d'office avec Docker Desktop, pas sous Linux
+    "--add-host=host.docker.internal:host-gateway"
+  ],
+
+  "postCreateCommand": "bash .devcontainer/post-create.sh",
+  // Identité git, clusters, puis récapitulatif de ce qui reste à faire
+  "postStartCommand": "bash .devcontainer/demarrage.sh",
+  // Clusters kind du conteneur (config) + cluster de l'hôte (hote.config,
+  // refait à chaque démarrage par kube-config.sh)
+  "remoteEnv": {
+    "KUBECONFIG": "/home/vscode/.kube/config:/home/vscode/.kube/hote.config",
+    // Claude Code range aussi .claude.json (connexion, réglages) dans ce
+    // dossier, donc dans son volume, au lieu de ~/.claude.json
+    "CLAUDE_CONFIG_DIR": "/home/vscode/.claude"
+  },
+  "remoteUser": "vscode",
+
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "vscjava.vscode-java-pack",
+        "vmware.vscode-boot-dev-pack",
+        "dbaeumer.vscode-eslint",
+        "esbenp.prettier-vscode",
+        "bradlc.vscode-tailwindcss",
+        "ms-python.python",
+        "charliermarsh.ruff",
+        "ms-azuretools.vscode-docker",
+        "ms-kubernetes-tools.vscode-kubernetes-tools",
+        "redhat.vscode-yaml"
+      ]
+    }
+  }
+}

package/.devcontainer/devzone

@@ -0,0 +1,138 @@
+#!/usr/bin/env bash
+# Modules facultatifs de devzone, activés à la demande, sans rebuild :
+#   devzone                          état des modules
+#   devzone activer <module>         active et applique tout de suite
+#   devzone desactiver <module>      désactive et applique tout de suite
+#   devzone appliquer                installe ce qui est actif (post-create.sh)
+#   devzone actif <module>           code 0 si actif (scripts de démarrage)
+# État propre à chaque utilisateur : ~/.config/devzone/modules (volume
+# devzone-config, survit aux rebuilds), une ligne « module=on|off ».
+set -euo pipefail
+
+ETAT="${DEVZONE_ETAT:-$HOME/.config/devzone/modules}"
+ICI="$(cd "$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")" && pwd)"
+MODULES=(ia kubernetes)
+
+# Assistants IA, versions figées : mettre à jour ici, puis devzone appliquer
+# (ou Rebuild Container)
+IA_PAQUETS=(@anthropic-ai/claude-code@2.1.286 opencode-ai@1.18.34)
+IA_NOMS=(@anthropic-ai/claude-code opencode-ai)
+
+description() {
+    case "$1" in
+        ia) echo "assistants IA : Claude Code, opencode" ;;
+        kubernetes) echo "connexion au cluster de l'hôte et metrics-server au démarrage" ;;
+    esac
+}
+
+connu() {
+    local m
+    for m in "${MODULES[@]}"; do [ "$m" = "$1" ] && return 0; done
+    return 1
+}
+
+# Premier démarrage (aucun état) : tout désactivé, sauf ia si une connexion
+# existe déjà dans les volumes (pas de régression pour qui s'en servait)
+initialiser() {
+    [ -f "$ETAT" ] && return 0
+    mkdir -p "$(dirname "$ETAT")"
+    local ia=off
+    if [ -f "$HOME/.claude/.credentials.json" ] || [ -f "$HOME/.local/share/opencode/auth.json" ]; then
+        ia=on
+        # stderr : initialiser est aussi appelé dans $(valeur …)
+        echo "devzone : connexion d'un assistant IA trouvée, module ia activé (devzone desactiver ia pour le retirer)" >&2
+    fi
+    printf 'ia=%s\nkubernetes=off\n' "$ia" >"$ETAT"
+}
+
+valeur() {
+    initialiser
+    local v
+    v="$(grep -E "^$1=" "$ETAT" | tail -1 | cut -d= -f2 || true)"
+    [ "$v" = on ] && echo on || echo off
+}
+
+ecrire() {
+    initialiser
+    local tmp
+    tmp="$(mktemp)"
+    grep -vE "^$1=" "$ETAT" >"$tmp" || true
+    echo "$1=$2" >>"$tmp"
+    mv "$tmp" "$ETAT"
+}
+
+appliquer_ia() {
+    if [ "$1" = on ]; then
+        npm install -g --no-fund --no-audit --loglevel=error "${IA_PAQUETS[@]}" >/dev/null
+        echo "devzone : ia actif : claude (puis /login), opencode auth login"
+    else
+        npm uninstall -g "${IA_NOMS[@]}" >/dev/null 2>&1 || true
+        echo "devzone : ia désactivé (connexions gardées dans leurs volumes)"
+    fi
+}
+
+appliquer_kubernetes() {
+    if [ "$1" = on ]; then
+        bash "$ICI/kube-config.sh"
+    else
+        rm -f "$HOME/.kube/hote.config"
+        echo "devzone : kubernetes désactivé (metrics-server reste installé sur les clusters où il l'a été)"
+    fi
+}
+
+# État complet : ✔ prêt, ✖ nécessaire, ○ facultatif, ⚠ à corriger ; chaque
+# point à faire avec sa commande (affiché à chaque démarrage)
+etat() {
+    local nom email statut m
+    echo "devzone : état (devzone pour le réafficher)"
+    nom="$(git config --get user.name || true)"
+    email="$(git config --get user.email || true)"
+    if [ -n "$nom" ] && [ -n "$email" ]; then
+        echo "  ✔ identité git    $nom <$email>"
+    else
+        echo "  ✖ identité git    nécessaire pour commiter : gh auth login -s workflow (automatique),"
+        echo "                    ou git config --file ~/.config/git/config user.name \"<nom>\" et user.email \"<email>\""
+    fi
+    if ! statut="$(gh auth status 2>&1)"; then
+        echo "  ○ GitHub          facultatif (push et PR, tickets repowarden) : gh auth login -s workflow"
+    elif grep -q "Token scopes:" <<<"$statut" && ! grep -q "'workflow'" <<<"$statut"; then
+        echo "  ⚠ GitHub          connecté, sans permission workflow (push de .github/workflows/ refusé) : gh auth refresh -h github.com -s workflow"
+    else
+        echo "  ✔ GitHub          connecté"
+    fi
+    for m in "${MODULES[@]}"; do
+        if [ "$(valeur "$m")" = on ]; then
+            printf '  ✔ module %-10s actif : %s\n' "$m" "$(description "$m")"
+        else
+            printf '  ○ module %-10s facultatif, %s : devzone activer %s\n' "$m" "$(description "$m")" "$m"
+        fi
+    done
+}
+
+changer() {
+    local m="${2:-}"
+    if [ -z "$m" ] || ! connu "$m"; then
+        echo "devzone : module inconnu : ${m:-(aucun)} ; modules : ${MODULES[*]}" >&2
+        exit 1
+    fi
+    ecrire "$m" "$1"
+    "appliquer_$m" "$1"
+}
+
+case "${1:-}" in
+    "" | etat | modules) etat ;;
+    activer) changer on "${2:-}" ;;
+    desactiver) changer off "${2:-}" ;;
+    appliquer)
+        [ "$(valeur ia)" = off ] || appliquer_ia on
+        ;;
+    actif)
+        connu "${2:-}" || { echo "devzone : module inconnu : ${2:-(aucun)}" >&2; exit 2; }
+        [ "$(valeur "$2")" = on ]
+        ;;
+    -h | --help | aide) sed -n '2,8p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//' ;;
+    *)
+        echo "devzone : commande inconnue : $1 (devzone --help)" >&2
+        exit 1
+        ;;
+esac

package/.devcontainer/git-identite.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Identité git, à chaque démarrage tant qu'elle manque : déduite du compte gh
+# (propre à chaque utilisateur, connexion gardée dans son volume) et écrite dans
+# ~/.config/git/config (volume devzone-git, survit aux rebuilds).
+# Une identité déjà définie (à la main, ou recopiée par VS Code dans
+# ~/.gitconfig) n'est jamais remplacée. Email noreply de GitHub : les commits
+# sont rattachés au compte sans exposer l'email personnel.
+set -euo pipefail
+
+CONFIG="$HOME/.config/git/config"
+nom_git="$(git config --get user.name || true)"
+email_git="$(git config --get user.email || true)"
+
+[ -n "$nom_git" ] && [ -n "$email_git" ] && exit 0
+
+# Sans gh : rien à déduire ; le récapitulatif de devzone le signale
+gh auth status >/dev/null 2>&1 || exit 0
+
+id="" login="" nom=""
+IFS=$'\t' read -r id login nom < <(gh api user --jq '[.id, .login, (.name // "")] | @tsv' 2>/dev/null || true)
+if [ -z "$id" ] || [ -z "$login" ]; then
+    echo "git-identite : compte GitHub illisible (réseau ?) ; relancer : bash .devcontainer/git-identite.sh"
+    exit 0
+fi
+
+[ -n "$nom_git" ] || git config --file "$CONFIG" user.name "${nom:-$login}"
+[ -n "$email_git" ] || git config --file "$CONFIG" user.email "${id}+${login}@users.noreply.github.com"
+echo "git-identite : $(git config --get user.name) <$(git config --get user.email)>"

package/.devcontainer/kube-config.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+# Clusters Kubernetes du conteneur, à chaque démarrage (le port du cluster de
+# l'hôte peut changer) :
+# - ~/.kube/hote.config : copie du ~/.kube de l'hôte (monté en lecture seule) où
+#   127.0.0.1/localhost deviennent host.docker.internal, l'hôte vu du conteneur ;
+#   tls-server-name garde le nom attendu par le certificat
+# - ~/.kube/config : clusters kind du conteneur, jamais touché ici
+# KUBECONFIG (devcontainer.json) combine les deux.
+# Module kubernetes (devzone activer kubernetes) : connexion au cluster de
+# l'hôte et metrics-server seulement s'il est actif ; les contextes kind sont
+# toujours remis (un cluster créé à la main reste utilisable).
+set -euo pipefail
+
+ICI="$(dirname "$0")"
+module=off
+bash "$ICI/devzone" actif kubernetes && module=on
+
+# DEVZONE_KUBE_SOURCE : tests fonctionnels (jamais le cluster de l'hôte)
+SOURCE="${DEVZONE_KUBE_SOURCE:-$HOME/.kube-host/config}"
+HOTE="$HOME/.kube/hote.config"
+
+mkdir -p "$HOME/.kube"
+rm -f "$HOTE"
+# Doit exister : sinon kind écrit dans hote.config, effacé au prochain démarrage
+[ -f "$HOME/.kube/config" ] || install -m 600 /dev/null "$HOME/.kube/config"
+
+if [ "$module" = on ] && [ -f "$SOURCE" ]; then
+    install -m 600 "$SOURCE" "$HOTE"
+    KUBECONFIG="$HOTE" kubectl config view \
+        -o jsonpath='{range .clusters[*]}{.name}{"\t"}{.cluster.server}{"\n"}{end}' |
+        while IFS=$'\t' read -r nom serveur; do
+            case "$serveur" in
+                https://127.0.0.1:* | https://localhost:*) ;;
+                *) continue ;;
+            esac
+            hote="${serveur#https://}"
+            hote="${hote%%:*}"
+            KUBECONFIG="$HOTE" kubectl config set-cluster "$nom" \
+                --server="https://host.docker.internal:${serveur##*:}" \
+                --tls-server-name="$hote" >/dev/null
+        done
+fi
+
+# Clusters kind qui ont survécu au redémarrage : contexte remis dans ~/.kube/config
+# (le Docker interne peut mettre quelques secondes à démarrer)
+for _ in 1 2 3 4 5 6 7 8 9 10; do docker info >/dev/null 2>&1 && break; sleep 1; done
+choix="$(KUBECONFIG="$HOME/.kube/config" kubectl config current-context 2>/dev/null || true)"
+for cluster in $(kind get clusters 2>/dev/null); do
+    kind export kubeconfig --name "$cluster" --kubeconfig "$HOME/.kube/config" >/dev/null 2>&1 || true
+done
+
+# Cluster actif : celui choisi avant (kubectl config use-context), sinon celui
+# de l'hôte s'il en a un (current-context de hote.config), sinon kind
+export KUBECONFIG="$HOME/.kube/config:$HOTE"
+if [ -n "$choix" ] && kubectl config use-context "$choix" >/dev/null 2>&1; then
+    :
+elif [ -f "$HOTE" ] && [ -n "$(KUBECONFIG="$HOTE" kubectl config current-context 2>/dev/null)" ]; then
+    KUBECONFIG="$HOME/.kube/config" kubectl config unset current-context >/dev/null
+fi
+
+# Clusters joignables, parmi ceux de l'hôte et ceux de kind
+joignables=0
+for contexte in $(kubectl config get-contexts -o name 2>/dev/null); do
+    if kubectl --context "$contexte" --request-timeout=3s get --raw /readyz >/dev/null 2>&1; then
+        echo "kube-config : cluster joignable : $contexte"
+        joignables=$((joignables + 1))
+    elif [[ "$contexte" == kind-* ]]; then
+        echo "kube-config : cluster kind en cours de démarrage : $contexte"
+        joignables=$((joignables + 1))
+    fi
+done
+# Module désactivé : le récapitulatif de devzone le signale
+[ "$module" = on ] || exit 0
+echo "kube-config : cluster actif : $(kubectl config current-context 2>/dev/null || echo aucun)"
+if [ "$joignables" -eq 0 ]; then
+    echo "kube-config : aucun cluster joignable ; en créer un dans le conteneur : kind create cluster"
+fi
+
+# CPU/RAM dans k9s : metrics-server sur les clusters joignables qui ne l'ont pas
+bash "$ICI/metrics-server.sh" || true

package/.devcontainer/metrics-server.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# Installe metrics-server (CPU/RAM dans k9s, kubectl top) sur les clusters qui
+# n'ont pas d'API Metrics. Docker Desktop et kind ne l'ont pas d'office.
+# Usage : metrics-server.sh [contexte...] (défaut : clusters locaux joignables)
+# --kubelet-insecure-tls : le kubelet de Docker Desktop et de kind a un
+# certificat auto-signé, sans cette option le pod ne devient jamais Ready.
+# Sortie en erreur si un contexte demandé est inconnu ou injoignable, ou si
+# une installation échoue (kube-config.sh l'appelle avec || true).
+set -euo pipefail
+
+VERSION=v0.9.0
+MANIFESTE="https://github.com/kubernetes-sigs/metrics-server/releases/download/${VERSION}/components.yaml"
+
+mapfile -t connus < <(kubectl config get-contexts -o name 2>/dev/null || true)
+demandes=$#
+if [ "$demandes" -eq 0 ]; then
+    # Clusters locaux seulement : jamais d'install automatique sur un cluster
+    # distant de l'hôte (prod, staging…) ; pour un autre, le nommer en argument
+    mapfile -t contextes < <(printf '%s\n' ${connus[@]+"${connus[@]}"} |
+        grep -E '^(kind-.*|docker-desktop|rancher-desktop|orbstack|minikube)$' || true)
+    set -- ${contextes[@]+"${contextes[@]}"}
+fi
+
+code=0
+joignables=0
+for contexte in "$@"; do
+    if [ "$demandes" -gt 0 ] && ! printf '%s\n' ${connus[@]+"${connus[@]}"} | grep -qxF -- "$contexte"; then
+        echo "metrics-server : contexte inconnu : $contexte (voir kubectl config get-contexts)" >&2
+        code=1
+        continue
+    fi
+    k=(kubectl --context "$contexte" --request-timeout=5s)
+    if ! "${k[@]}" get --raw /readyz >/dev/null 2>&1; then
+        # Sans argument : kind peut être en cours de démarrage, ignoré
+        if [ "$demandes" -gt 0 ]; then
+            echo "metrics-server : cluster injoignable : $contexte" >&2
+            code=1
+        fi
+        continue
+    fi
+    joignables=$((joignables + 1))
+    if "${k[@]}" get apiservice v1beta1.metrics.k8s.io >/dev/null 2>&1; then
+        echo "metrics-server : déjà présent : $contexte"
+        continue
+    fi
+    if "${k[@]}" apply -f "$MANIFESTE" >/dev/null &&
+        "${k[@]}" -n kube-system patch deployment metrics-server --type=json \
+            -p '[{"op":"add","path":"/spec/template/spec/containers/0/args/-","value":"--kubelet-insecure-tls"}]' >/dev/null &&
+        # Marque : make desinstaller ne retire que ce que devzone a installé
+        "${k[@]}" -n kube-system label deployment metrics-server devzone=installe --overwrite >/dev/null; then
+        echo "metrics-server : installé ($VERSION) : $contexte (métriques dans ~1 min)"
+    else
+        echo "metrics-server : échec de l'installation : $contexte" >&2
+        code=1
+    fi
+done
+
+if [ "$demandes" -eq 0 ] && [ "$joignables" -eq 0 ]; then
+    echo "metrics-server : aucun cluster local joignable ; après kind create cluster : bash .devcontainer/metrics-server.sh"
+fi
+exit "$code"

package/.devcontainer/post-create.sh

@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+# Étapes qui ne peuvent pas être dans l'image (Dockerfile) :
+# - volumes montés au démarrage seulement
+# - npm fourni par la feature node, ajoutée après le Dockerfile
+set -euo pipefail
+
+# Volumes nommés créés en root → rendre au user vscode
+# (et ~/.config, créé par Docker pour monter ~/.config/opencode)
+sudo chown -R vscode:vscode /home/vscode/.m2 /home/vscode/.local /home/vscode/.claude \
+    /home/vscode/.config/opencode /home/vscode/.config/gh /home/vscode/.config/git \
+    /home/vscode/.config/devzone
+sudo chown vscode:vscode /home/vscode/.config
+
+# Git : dépôts du conteneur déclarés sûrs (leur propriétaire peut différer de
+# l'utilisateur qui lance git : volumes, Docker Desktop, outils lancés à part),
+# et accès à GitHub par le jeton de gh, conservé dans son volume (https, même
+# pour les remotes en git@github.com:, sans clé ssh à recopier)
+git config --global --add safe.directory /workspaces/devzone
+git config --global --add safe.directory '/workspaces/devzone/workspace/*'
+git config --global credential.https://github.com.helper ''
+git config --global --add credential.https://github.com.helper '!gh auth git-credential'
+git config --global url.https://github.com/.insteadOf git@github.com:
+
+# repowarden, version figée (il installe des hooks git globaux) ; mettre à jour
+# en changeant la version ici, puis Rebuild Container
+npm install -g repowarden@4.8.3
+repowarden install --global --lang fr
+
+# Modules facultatifs (assistants IA, Kubernetes) : commande devzone, état
+# gardé dans le volume devzone-config ; installe ce qui est actif
+sudo ln -sf /workspaces/devzone/.devcontainer/devzone /usr/local/bin/devzone
+devzone appliquer
+
+# Ce qui reste à faire (identité git, GitHub, modules) : récapitulatif de
+# devzone, affiché à chaque démarrage (demarrage.sh)
+
+recap="java $(java -version 2>&1 | head -1 | cut -d'"' -f2), node $(node -v), python $(python3 --version | cut -d' ' -f2), repowarden $(repowarden --version)"
+! command -v claude >/dev/null || recap+=", claude $(claude --version | cut -d' ' -f1)"
+! command -v opencode >/dev/null || recap+=", opencode $(opencode --version)"
+echo "devzone prêt : $recap"

package/.gitattributes

@@ -0,0 +1,5 @@
+# Scripts lancés dans le conteneur Linux : fins de ligne LF même sur un
+# checkout Windows (bash échoue sur les CRLF)
+*.sh        text eol=lf
+Dockerfile  text eol=lf
+Makefile    text eol=lf

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SimBienvenueHoulBoumi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Makefile

@@ -0,0 +1,39 @@
+# Pilotage du devcontainer sans VS Code
+DC     := npx -y @devcontainers/cli
+WS     := --workspace-folder $(CURDIR)
+FILTRE := --filter "label=devcontainer.local_folder=$(CURDIR)"
+LOG    := $(CURDIR)/.devzone.log
+
+.DEFAULT_GOAL := help
+.PHONY: help up shell stop down rebuild status test-fonctionnel desinstaller
+
+help: ## Liste les commandes
+	@grep -E '^[a-z-]+:.*## ' $(MAKEFILE_LIST) | awk -F':.*## ' '{printf "  make %-16s %s\n", $$1, $$2}'
+
+up: ## Lance le conteneur (le crée si absent)
+	@$(DC) up $(WS) >$(LOG) 2>&1 && echo "devzone lancé" \
+		|| { tail -15 $(LOG); echo "échec — log complet : .devzone.log"; exit 1; }
+
+shell: up ## Ouvre un shell dans le conteneur
+	@$(DC) exec $(WS) bash
+
+stop: ## Arrête le conteneur (état conservé)
+	@ids=$$(docker ps -q $(FILTRE)); if [ -z "$$ids" ]; then echo "déjà arrêté"; else docker stop $$ids >/dev/null && echo "devzone arrêté"; fi
+
+down: ## Supprime le conteneur (volumes, image et Docker interne conservés)
+	@ids=$$(docker ps -aq $(FILTRE)); if [ -z "$$ids" ]; then echo "aucun conteneur"; else \
+		docker inspect $$ids --format 'IMAGE={{.Config.Image}}{{range .Mounts}}{{if eq .Destination "/var/lib/docker"}} DIND={{.Name}}{{end}}{{end}}' | head -1 | tr ' ' '\n' > .devzone.etat; \
+		docker rm -f $$ids >/dev/null && echo "devzone supprimé (désinstallation complète : make desinstaller)"; fi
+
+rebuild: ## Reconstruit de zéro (après modif de .devcontainer/)
+	@$(DC) up $(WS) --remove-existing-container >$(LOG) 2>&1 && echo "devzone reconstruit" \
+		|| { tail -15 $(LOG); echo "échec — log complet : .devzone.log"; exit 1; }
+
+status: ## État du conteneur
+	@docker ps -a $(FILTRE) --format '{{.Status}}' | grep . || echo "aucun conteneur"
+
+test-fonctionnel: ## Tests fonctionnels : devzone isolé, construit puis supprimé (5 à 10 min)
+	@bash test/fonctionnel.sh
+
+desinstaller: ## Supprime tout ce que devzone a créé, après confirmation (GARDER=connexions : garde les connexions)
+	@GARDER="$(GARDER)" bash desinstaller.sh

package/README.md

@@ -1,3 +1,271 @@
-# Temporary Holding Version
+# devzone
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Environnement de développement complet dans un conteneur (devcontainer) : les mêmes outils, aux mêmes versions, sur Mac, Linux et Windows. Rien à installer sur ta machine à part Docker.
+
+| Domaine | Outils |
+|---|---|
+| Langages | Java 21 + Maven, Node LTS + pnpm, Python 3.12 + uv |
+| Conteneurs, Kubernetes | Docker (Docker-in-Docker), kubectl, helm, k9s, kind ; connexion au cluster de l'hôte : [module](#modules) `kubernetes` |
+| GitHub, qualité | gh, repowarden (hooks git globaux), shellcheck, bats, actionlint, gitleaks, ruff, vulture, pytest |
+| Assistants IA | Claude Code, opencode : [module](#modules) `ia`, désactivé par défaut |
+
+**Ce qui est facultatif est désactivé par défaut** et s'active à la demande, sans rebuild (voir [Modules](#modules)) : les assistants IA (`devzone activer ia`) et la connexion au cluster Kubernetes de ta machine (`devzone activer kubernetes`). devzone ne crée jamais de cluster : sans celui de ta machine, tu en crées un si besoin avec `kind create cluster` (voir [Kubernetes](#kubernetes)).
+
+## Démarrage rapide
+
+1. **Prérequis** : Docker (Docker Desktop, ou Docker Engine sous Linux), puis **soit** VS Code + extension *Dev Containers*, **soit** Node (pour `npx`) et `make`. Facultatif, pour Kubernetes : activer le cluster de Docker Desktop (*Settings → Kubernetes → Enable Kubernetes*). Sous Windows : cloner avec Git for Windows (les scripts restent en fins de ligne LF grâce à `.gitattributes`).
+2. **Obtenir devzone**, au choix :
+   - `npx devzone mon-devzone` : crée le dossier `mon-devzone/` et lance le conteneur (paquet npm `devzone`, une fois publié) ;
+   - ou `git clone https://github.com/SimBienvenueHoulBoumi/devzone.git`.
+   
+   **Lancer** depuis ce dossier : `make shell` (ou, dans VS Code, *Dev Containers: Reopen in Container*). Le premier build prend quelques minutes (4 à 5 min mesurées, plus le téléchargement des images de base sur une machine neuve).
+3. **Identité git**, une seule fois (nécessaire pour commiter, gardée ensuite, même après `make rebuild`) :
+   - avec GitHub : `gh auth login -s workflow` ; l'identité est déduite du compte ;
+   - sans GitHub : `git config --file ~/.config/git/config user.name "<nom>"`, puis de même `user.email "<email>"`.
+
+   **Facultatif** : GitHub (push et PR GitHub, tickets et bots repowarden), `devzone activer ia` (assistants IA), `devzone activer kubernetes` (cluster de ta machine) ; voir [Connexions et identité](#connexions-et-identité) et [Modules](#modules).
+4. **Vérifier** : `java -version`, `node -v`, `python3 --version`, `repowarden --version` ; avec un cluster : `kubectl get nodes`.
+
+**À chaque démarrage, un récapitulatif** dit ce qui est prêt et ce qui reste à faire, chaque point avec sa commande ; `devzone` le réaffiche à tout moment :
+
+```text
+devzone : état (devzone pour le réafficher)
+  ✖ identité git    nécessaire pour commiter : gh auth login -s workflow (automatique),
+                    ou git config --file ~/.config/git/config user.name "<nom>" et user.email "<email>"
+  ○ GitHub          facultatif (push et PR, tickets repowarden) : gh auth login -s workflow
+  ○ module ia         facultatif, assistants IA : Claude Code, opencode : devzone activer ia
+  ○ module kubernetes facultatif, connexion au cluster de l'hôte et metrics-server au démarrage : devzone activer kubernetes
+```
+
+✔ prêt, ✖ nécessaire, ○ facultatif, ⚠ à corriger (par exemple GitHub connecté sans la permission `workflow`). Dans VS Code, il s'affiche dans le terminal de création du conteneur.
+
+## Modules
+
+Les fonctionnalités facultatives sont des modules, **désactivés par défaut**, activés à la demande depuis le conteneur, sans rebuild :
+
+```bash
+devzone                        # état : identité git, GitHub, modules
+devzone activer <module>       # active et applique tout de suite
+devzone desactiver <module>    # désactive et applique tout de suite
+```
+
+| Module | Activé | Désactivé |
+|---|---|---|
+| `ia` | Claude Code et opencode installés (versions figées), réinstallés à chaque rebuild ; se connecter : `claude` (puis `/login`), `opencode auth login` | désinstallés ; les connexions restent dans leurs volumes |
+| `kubernetes` | à chaque démarrage : connexion au cluster de ta machine et metrics-server sur les clusters locaux (CPU et RAM dans k9s) | aucune connexion au cluster de ta machine ; kubectl, helm, k9s et kind restent installés, un cluster kind créé à la main reste utilisable ; metrics-server n'est pas retiré des clusters où il a été installé |
+
+Le choix est **propre à chaque utilisateur** et gardé dans le volume `devzone-config` (il survit aux rebuilds). Au premier démarrage, si une connexion Claude Code ou opencode existe déjà dans les volumes, le module `ia` est activé (et signalé) : rien ne disparaît pour qui s'en servait.
+
+## Commandes
+
+| Action | VS Code (`Cmd+Shift+P`) | `make` | Sans `make` (Windows) |
+|---|---|---|---|
+| Lancer | *Dev Containers: Reopen in Container* | `make up` | `npx @devcontainers/cli up --workspace-folder .` |
+| Ouvrir un shell | terminal de VS Code | `make shell` | `npx @devcontainers/cli exec --workspace-folder . bash` |
+| Arrêter | *Remote: Close Remote Connection* (le conteneur s'arrête avec la fenêtre) | `make stop` | — |
+| Supprimer le conteneur | — | `make down` | — |
+| Reconstruire (après une modification de `.devcontainer/`) | *Dev Containers: Rebuild Container* | `make rebuild` | `npx @devcontainers/cli up --workspace-folder . --remove-existing-container` |
+| État | — | `make status` | — |
+| **Désinstaller** (tout ce que devzone a créé, après confirmation) | — | `make desinstaller` | `bash desinstaller.sh` |
+
+`make` seul affiche la liste. Les journaux de `up` et `rebuild` vont dans `.devzone.log` ; seule la fin s'affiche en cas d'échec.
+
+> Ne pas lancer `make up` pendant que VS Code ouvre ou reconstruit le conteneur : deux lancements simultanés créent des conteneurs en double.
+
+## Connexions et identité
+
+**GitHub (facultatif)** : sert à pousser et ouvrir des PR sur GitHub, aux tickets et bots repowarden, et donne l'identité git automatiquement. Sans GitHub, git fonctionne normalement (dépôts locaux, autre hébergeur) ; seule l'identité se règle à la main. Pour l'utiliser : `gh auth login -s workflow`. Git passe alors par le jeton de `gh` (https, même pour les remotes en `git@github.com:`), sans clé ssh à recopier. Les dépôts de `/workspaces/devzone` sont déclarés sûrs (`safe.directory`).
+- **Permission `workflow`** : sans elle, GitHub refuse tout push qui modifie `.github/workflows/` (fréquent avec repowarden). Compte déjà connecté : `gh auth refresh -h github.com -s workflow`.
+- **Depuis `make shell`**, aucun navigateur ne s'ouvre depuis le conteneur : copier le code affiché par `gh` et ouvrir https://github.com/login/device à la main. L'avertissement « No clipboard utilities available » est sans conséquence.
+
+**Identité git** (nécessaire pour commiter) : sans GitHub, à régler à la main (`git config --file ~/.config/git/config user.name "<nom>"` et `user.email "<email>"`) ; avec GitHub, déduite du compte `gh` à chaque démarrage, tant qu'elle manque (`git-identite.sh`) :
+- nom du profil GitHub (sinon le login) ;
+- email noreply `<id>+<login>@users.noreply.github.com` : les commits sont rattachés au compte, l'email personnel n'est pas exposé.
+
+Une identité déjà définie n'est jamais remplacée. Pour un autre email : `git config --file ~/.config/git/config user.email "<email>"`. Après un `gh auth login` en cours de session : `bash .devcontainer/git-identite.sh`.
+
+**Assistants IA** (module `ia`, voir [Modules](#modules)) : `devzone activer ia`, puis `claude` (puis `/login`), `opencode auth login`.
+
+Chaque connexion est **propre à l'utilisateur** : elle vit dans les volumes Docker de sa machine (voir [Données conservées](#données-conservées)). Le dépôt ne contient aucun identifiant.
+
+## Mettre en route un projet
+
+Tes projets vont dans `workspace/` (`/workspaces/devzone/workspace` dans le conteneur), chacun avec son propre dépôt git. Les hooks repowarden y sont actifs d'office.
+
+**Projet existant, déjà équipé de repowarden** (`.repowarden.conf` et workflows présents) : il suffit de le cloner.
+
+```bash
+cd /workspaces/devzone/workspace
+git clone https://github.com/<compte>/<projet>.git
+cd <projet>
+repowarden            # état du poste et du dépôt, étape suivante
+```
+
+**Nouveau projet, ou projet sans repowarden** :
+
+```bash
+cd /workspaces/devzone/workspace
+mkdir <projet> && cd <projet> && git init -b main     # ou git clone d'un dépôt existant
+# … premiers fichiers, puis un premier commit : git add . && git cc
+gh repo create <compte>/<projet> --private --source . --push   # dépôt GitHub (si absent)
+repowarden bots       # CI, releases, tickets, GitHub App, protection : chacun avec ton accord
+repowarden            # vérifier
+```
+
+`repowarden bots` demande le flux (`main` seule, ou `develop` → `main`), montre ce qu'il va créer, puis attend ta confirmation ; un fichier existant n'est jamais écrasé. Il faut `gh` connecté et les droits d'administration du dépôt GitHub.
+
+## Travailler sur un projet
+
+- **Hooks repowarden** : installés globalement (`repowarden install --global --lang fr`), ils s'appliquent à tout dépôt cloné dans le conteneur (messages de commit, secrets, formatage, tests). Ensuite, suivre les règles du projet (`AGENTS.md`, `CONTRIBUTING.md`) : `repowarden ticket <n>`, `repowarden cc …`.
+- **GitHub App** (proposée par `repowarden bots`, ou `repowarden app init`) : sans elle, les workflows agissent sous le bot `github-actions`, dont les actions ne déclenchent aucun autre workflow (PR brouillon sans CI, merge automatique sans préversion…) ; voir [Dépannage](#dépannage).
+- **Vérifications de la CI de repowarden** en local : `shellcheck`, `actionlint`, `bats test/`. actionlint est à la même version que la CI ; shellcheck et bats sont ceux d'Ubuntu 24.04 et peuvent différer légèrement.
+
+## Kubernetes
+
+devzone fournit les outils, pas le cluster, et n'en crée jamais tout seul. Avec le module `kubernetes` actif (`devzone activer kubernetes`), il se connecte à chaque démarrage au cluster de l'hôte s'il existe et répond (Docker Desktop sur Mac, Windows ou Linux). Sinon, ou en plus, créer un cluster dans le conteneur :
+
+```bash
+kind create cluster          # ~2 min la première fois
+kubectl config get-contexts  # clusters de l'hôte + clusters kind
+kubectl config use-context <nom>
+```
+
+- **Cluster actif** : celui de l'hôte par défaut ; un choix fait avec `use-context` est gardé aux redémarrages.
+- **Clusters kind** : tournent dans le Docker interne, redémarrent avec le conteneur, sont conservés par `make rebuild` et `make down` ; supprimés par `kind delete cluster` (ou `make desinstaller`).
+- **CPU et RAM dans k9s** (`kubectl top`) : module `kubernetes` actif, metrics-server est installé au démarrage sur les clusters **locaux** qui ne l'ont pas (Docker Desktop, kind…), jamais sur un cluster distant. Après un `kind create cluster` : `bash .devcontainer/metrics-server.sh` (ou `… metrics-server.sh <contexte>` pour un cluster précis).
+- **Cluster de l'hôte** : `~/.kube` est monté en lecture seule, jamais modifié ; sa copie adaptée est `~/.kube/hote.config` (`127.0.0.1` remplacé par `host.docker.internal`). Après un changement de cluster sur l'hôte : `make stop && make up`.
+- **Messages de démarrage** (`kube-config : …`, `metrics-server : …`, récapitulatif) : dans le terminal de création, ou en relançant `bash .devcontainer/demarrage.sh`.
+
+Le cluster de l'hôte n'est pas joignable dans deux cas (kind fonctionne quand même) :
+- **Codespaces, machine distante** : pas de `~/.kube` local ;
+- **Linux avec Docker Engine** : un cluster kind ou minikube de l'hôte écoute sur `127.0.0.1`, invisible du conteneur. Un cluster qui écoute sur toutes les interfaces (k3s, kubeadm) est joignable.
+
+## Données conservées
+
+Le conteneur est jetable ; ce qui compte vit dans des volumes Docker, sur ta machine.
+
+| Volume | Contenu | `make stop` | `make down` | `make rebuild` |
+|---|---|---|---|---|
+| `devzone-gh` | connexion GitHub (`gh`) | gardé | gardé | gardé |
+| `devzone-git` | identité git (`~/.config/git/config`) | gardé | gardé | gardé |
+| `devzone-claude` | connexion et réglages de Claude Code | gardé | gardé | gardé |
+| `devzone-opencode-config`, `devzone-opencode-data` | connexion et réglages d'opencode | gardé | gardé | gardé |
+| `devzone-config` | modules activés (`devzone activer`) | gardé | gardé | gardé |
+| `devzone-m2`, `devzone-pnpm` | caches Maven (`~/.m2`) et pnpm | gardé | gardé | gardé |
+| volume du Docker interne | images Docker et clusters kind du conteneur | gardé | gardé | gardé |
+| `workspace/` (dossier de l'hôte) | tes projets | gardé | gardé | gardé |
+
+Tout le reste du conteneur (paquets installés à la main, fichiers hors de ces emplacements) est perdu à `make down` et `make rebuild`. Le Docker interne est isolé : ses images ne sont pas partagées avec Docker Desktop.
+
+## Désinstaller
+
+`make down` ne supprime que le conteneur. Pour retirer **tout ce que devzone a créé** sur ta machine :
+
+```bash
+make desinstaller                     # liste ce qui sera supprimé, puis demande « oui »
+make desinstaller GARDER=connexions   # pareil, mais garde gh, git, Claude Code, opencode et les modules
+```
+
+Installé par npm : `devzone desinstaller` dans le dossier (même chose), **puis** `npm uninstall -g devzone`. npm ne retire que la commande `devzone` : sans la désinstallation, image, volumes et Docker interne resteraient.
+
+| Supprimé | Jamais touché |
+|---|---|
+| conteneur et image `vsc-devzone-…` | `workspace/` (tes projets) |
+| volumes `devzone-*` | l'image de base `mcr.microsoft.com/devcontainers/base` (partagée) |
+| volume du Docker interne (images et clusters kind) | un metrics-server que devzone n'a pas installé |
+| metrics-server **installé par devzone** sur les clusters locaux de ta machine (il porte l'étiquette `devzone=installe` ; vérifié avec le `kubectl` de ta machine) | |
+
+Fonctionne aussi après un `make down` : celui-ci note l'image et le Docker interne dans `.devzone.etat`. À la fin, la commande affiche ce qui reste à retirer toi-même si tu le souhaites : le cache `npx` (`~/.npm/_npx`), l'autorisation « GitHub CLI » de ton compte (*GitHub → Settings → Applications*) et le dossier `devzone/`. Sans terminal : `CONFIRMER=oui make desinstaller`.
+
+## Mettre à jour un outil
+
+| Outil | Où | Puis |
+|---|---|---|
+| k9s, actionlint, gitleaks, kind | `.devcontainer/Dockerfile` : `ARG …_VERSION` **et** les empreintes `sha256` (arm64 + amd64) | `make rebuild` |
+| uv, ruff, vulture, pytest | `.devcontainer/Dockerfile` : `ARG …_VERSION` | `make rebuild` |
+| repowarden | `.devcontainer/post-create.sh` : `repowarden@x.y.z` | `make rebuild` |
+| Claude Code, opencode | `.devcontainer/devzone` : `IA_PAQUETS` (`@anthropic-ai/claude-code@x.y.z`, `opencode-ai@x.y.z`) | `devzone activer ia` (ou `make rebuild`) |
+| metrics-server | `.devcontainer/metrics-server.sh` : `VERSION` | `bash .devcontainer/metrics-server.sh` sur un nouveau cluster |
+| Java, Node, Python, Docker, kubectl, helm, gh | `.devcontainer/devcontainer.json` (features), versions figées dans `devcontainer-lock.json` | `npx @devcontainers/cli upgrade --workspace-folder .` puis `make rebuild` |
+
+Empreinte d'une archive : `curl -fsSL <url> | shasum -a 256`.
+
+## Tests
+
+| Tests | Commande | Où | Durée |
+|---|---|---|---|
+| Commande `devzone` du conteneur et commande npm (unitaires) | `bats test/` | dans le conteneur | quelques secondes |
+| Fonctionnels : un devzone construit et utilisé comme par un utilisateur (outils, modules, Kubernetes avec kind, hooks repowarden, redémarrage, rebuild) | `make test-fonctionnel` | sur ta machine (Docker, Node) | 5 à 10 min |
+
+Les tests fonctionnels travaillent sur une copie du dépôt, avec leurs propres volumes (`devzone-test-…`), puis suppriment tout (conteneur, volumes, image), même en cas d'échec : ton devzone, tes connexions et le cluster de ta machine ne sont jamais touchés (seul un cluster kind de test est utilisé). En CI, le workflow `fonctionnel` les lance sur chaque PR qui modifie `.devcontainer/`, `test/` ou le `Makefile`, et à la main (*Actions → fonctionnel → Run workflow*).
+
+## Versions et livraison
+
+Flux `develop` → `main`, géré par repowarden, **sans geste après le merge d'un ticket** :
+1. Le travail entre dans `develop` (branche par défaut), par une PR liée à un ticket. **Son merge est la validation humaine.** Une PR de travail ouverte vers `main` est reciblée vers `develop` par la CI.
+2. Le bot de release publie aussitôt une **préversion** `vX.Y.Z-next.N` et tient à jour la **PR de livraison** `develop` → `main`.
+3. La GitHub App **merge la PR de livraison** dès que ses vérifications sont vertes (`repowarden`, et `livraison` : préversion publiée). Ce merge publie le tag `vX.Y.Z` et la [release GitHub](https://github.com/SimBienvenueHoulBoumi/devzone/releases). Une vérification rouge bloque la livraison, visible sur la PR.
+
+`main` reste ainsi à jour avec `develop`. La version suit les Conventional Commits : `fix` → correctif, `feat` → mineure ; une livraison sans `fix` ni `feat` (documentation, CI…) met `main` à jour sans nouvelle version.
+
+**Réglages, au choix du mainteneur** :
+
+| Réglage | Où | Effet |
+|---|---|---|
+| Livraison automatique (défaut de devzone) | rien | la PR de livraison part d'elle-même (job `livraison-auto` de `release.yml`) |
+| Livraison manuelle | variable de dépôt `LIVRAISON_AUTO=non` (*Settings → Secrets and variables → Actions → Variables*) | la PR de livraison attend ton merge |
+| Préversion à chaque merge (devzone) ou le soir | `release.yml`, job `release` : `preversion-on-push: true` ou rien | sans préversion à chaque merge, la livraison attend celle du soir |
+| Préversion obligatoire avant une version stable (défaut, celui de devzone) | `release.yml`, job `release` : rien, ou `preversion-obligatoire: false` pour la désactiver | désactivée, la vérification `livraison` passe d'office (« préversion non exigée ») : la PR de livraison n'attend plus de préversion, mais la version stable n'a pas été testée en préversion |
+
+Prérequis de la livraison automatique : la GitHub App du dépôt (`repowarden app init`, lancé sur ta machine ; voir [Dépannage](#dépannage)). Sans elle, un merge fait par le jeton des Actions ne déclencherait pas la release.
+
+## Dépannage
+
+| Symptôme | Cause | Solution |
+|---|---|---|
+| `git push` refusé : « refusing to allow an OAuth App to create or update workflow … without `workflow` scope » | jeton `gh` sans la permission `workflow` | `gh auth refresh -h github.com -s workflow` |
+| PR bloquée, run `action_required`, bandeau « Approve workflows to run » | PR ouverte ou poussée par le bot `github-actions` : pour les événements `pull_request` `opened`, `synchronize` et `reopened`, GitHub attend l'accord d'une personne ayant l'écriture ([doc GitHub](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/trigger-a-workflow)) | vérifier les changements (surtout `.github/workflows/`), puis *Approve workflows to run* ; pour ne plus avoir à le faire : `repowarden app init` dans le projet |
+| PR de livraison bloquée : « aucune préversion vX.Y.Z-next.N » | la préversion n'est pas encore publiée (sans `preversion-on-push`, elle part le soir) | attendre celle du soir, *Actions → release → Run workflow* sur `develop`, `preversion-on-push: true`, ou ne plus l'exiger : `preversion-obligatoire: false` |
+| PR de livraison restée ouverte | une vérification rouge (voir la PR), `LIVRAISON_AUTO=non`, ou GitHub App absente (job `livraison-auto` en échec) | corriger la vérification ; `repowarden app init` sur ta machine |
+| `repowarden app init` depuis `make shell` : la page `http://127.0.0.1:…` ne s'ouvre pas, ou GitHub ne revient pas | la page est servie dans le conteneur, injoignable depuis le navigateur de ta machine | lancer la commande **sur ta machine** : `npx -y repowarden app init --repo <compte>/<dépôt>` |
+| `repowarden app init` : « nom déjà utilisé » | un essai précédent a créé l'App sans en récupérer les identifiants | supprimer l'App orpheline (*GitHub → Settings → Developer settings → GitHub Apps*), ou `--nom <autre-nom>` |
+| `git commit` : « Please tell me who you are » | identité git absente | avec GitHub : `gh auth login -s workflow` puis `bash .devcontainer/git-identite.sh` ; sans GitHub : `git config --file ~/.config/git/config user.name "<nom>"` et `user.email "<email>"` |
+| `gh auth login` : « Press Enter to open … in your browser », rien ne s'ouvre | pas de navigateur dans le conteneur (`make shell`) | ouvrir https://github.com/login/device à la main et saisir le code |
+| `k9s` : `Error: exit status 1` puis son aide ; `kubectl` : `localhost:8080` … `connection refused` | aucun cluster actif (module `kubernetes` désactivé, ou pas de cluster sur ta machine) | `devzone activer kubernetes` (cluster de ta machine), `kind create cluster`, ou `kubectl config use-context <nom>` |
+| `claude` ou `opencode` : « command not found » | module `ia` désactivé | `devzone activer ia` |
+| CPU et RAM vides dans k9s | metrics-server absent du cluster | `bash .devcontainer/metrics-server.sh` |
+| Deux conteneurs devzone | `make up` lancé pendant que VS Code ouvrait le conteneur | `make down`, puis un seul lancement |
+| Windows (Git Bash, MSYS) : `~/.kube` introuvable | `HOME` et `USERPROFILE` concaténés dans le chemin monté | lancer depuis VS Code ou PowerShell |
+| Pas de `~/.kube` sur l'hôte | Docker le crée vide au démarrage (sous Linux avec Docker Engine, il appartient à root) | rien à faire : le conteneur démarre quand même |
+
+## Organisation
+
+```text
+devzone/
+├── .devcontainer/
+│   ├── Dockerfile              # image de base + outils figés (versions et sha256)
+│   ├── devcontainer.json       # features (langages, Docker, Kubernetes, gh), volumes, extensions VS Code
+│   ├── devcontainer-lock.json  # versions figées des features
+│   ├── devzone                 # commande devzone : modules (ia, kubernetes), versions des assistants IA
+│   ├── post-create.sh          # premier démarrage : droits des volumes, git, repowarden, modules actifs
+│   ├── demarrage.sh            # chaque démarrage : identité git, clusters, puis récapitulatif (devzone)
+│   ├── kube-config.sh          # contextes kind ; module kubernetes : cluster de l'hôte, metrics-server
+│   ├── metrics-server.sh       # metrics-server sur les clusters locaux (CPU et RAM dans k9s)
+│   └── git-identite.sh         # identité git déduite du compte gh si elle manque
+├── .github/workflows/
+│   ├── fonctionnel.yml         # tests fonctionnels (PR touchant .devcontainer/, test/ ou le Makefile)
+│   ├── repowarden.yml          # vérifications repowarden de chaque PR (PR mal visée reciblée vers develop)
+│   ├── tickets.yml             # suivi des tickets : branche, PR brouillon, statuts jusqu'à la production
+│   ├── release.yml             # préversions sur develop, livraison develop → main
+│   └── nettoyage.yml           # branches mergées supprimées (main et develop conservées)
+├── .repowarden.conf            # réglages repowarden : flux develop → main
+├── Makefile                    # pilotage sans VS Code
+├── desinstaller.sh             # make desinstaller : retire tout ce que devzone a créé
+├── bin/devzone                 # commande npm : npx devzone <dossier>, devzone desinstaller
+├── package.json, LICENSE       # paquet npm devzone (licence MIT)
+├── test/
+│   ├── devzone.bats            # tests de la commande devzone (bats test/)
+│   ├── cli.bats                # tests de la commande npm et du contenu du paquet
+│   └── fonctionnel.sh          # tests fonctionnels (make test-fonctionnel)
+└── workspace/                  # tes projets (ignorés par git, chacun son dépôt)
+```

package/bin/devzone

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+# Commande devzone sur ta machine (paquet npm) :
+#   devzone <dossier>        crée un devzone dans <dossier> puis le lance
+#   devzone desinstaller     dans un dossier devzone : retire tout ce qu'il a créé
+#   devzone --version | --help
+# Dans le conteneur, « devzone » est une autre commande : les modules
+# (.devcontainer/devzone).
+# DEVZONE_SANS_DEMARRER=1 : copie seule, sans lancer le conteneur (tests).
+set -euo pipefail
+
+PAQUET="$(cd "$(dirname "$(readlink -f "${BASH_SOURCE[0]}" 2>/dev/null || echo "${BASH_SOURCE[0]}")")/.." && pwd)"
+# Fichiers d'un devzone (même liste que « files » de package.json, sans bin/)
+FICHIERS=(.devcontainer Makefile .gitattributes desinstaller.sh README.md LICENSE)
+
+version() { node -p "require('$PAQUET/package.json').version" 2>/dev/null || echo inconnue; }
+
+aide() {
+    cat <<EOF
+devzone $(version) : environnement de développement conteneurisé
+
+  devzone <dossier>        crée un devzone dans <dossier> puis le lance (make up)
+  devzone desinstaller     dans un dossier devzone : retire conteneur, image, volumes
+                           (à lancer avant npm uninstall -g devzone)
+  devzone --version
+EOF
+}
+
+creer() {
+    local cible="$1"
+    if [ -e "$cible" ] && [ -n "$(ls -A "$cible" 2>/dev/null)" ]; then
+        echo "✖ $cible existe et n'est pas vide : rien n'est écrasé. Choisis un autre dossier." >&2
+        exit 1
+    fi
+    mkdir -p "$cible/workspace"
+    cp -R "${FICHIERS[@]/#/$PAQUET/}" "$cible/"
+    touch "$cible/workspace/.gitkeep"
+    # npm n'embarque jamais .gitignore : écrit ici
+    cat >"$cible/.gitignore" <<'EOF'
+# Chaque projet du workspace a son propre dépôt git
+workspace/*
+!workspace/.gitkeep
+
+.DS_Store
+.devzone.log
+.devzone.etat
+EOF
+    chmod +x "$cible/desinstaller.sh"
+    cible="$(cd "$cible" && pwd)"
+    echo "✔ devzone $(version) créé dans $cible"
+    if [ -n "${DEVZONE_SANS_DEMARRER:-}" ]; then
+        echo "Pour le lancer : cd $cible && make up"
+        return 0
+    fi
+    echo "▶ Lancement (quelques minutes la première fois)…"
+    if command -v make >/dev/null 2>&1; then
+        make -C "$cible" up
+    else
+        npx -y @devcontainers/cli up --workspace-folder "$cible" >"$cible/.devzone.log" 2>&1 || {
+            tail -15 "$cible/.devzone.log"
+            echo "✖ échec ; journal : $cible/.devzone.log" >&2
+            exit 1
+        }
+    fi
+    echo "Ensuite : cd $cible && make shell (ou ouvre le dossier dans VS Code : Reopen in Container)."
+}
+
+case "${1:-}" in
+    "" | -h | --help | aide) aide ;;
+    -v | --version) version ;;
+    desinstaller)
+        if [ ! -f desinstaller.sh ] || [ ! -d .devcontainer ]; then
+            echo "✖ À lancer dans un dossier devzone (desinstaller.sh introuvable ici)." >&2
+            exit 1
+        fi
+        bash desinstaller.sh
+        ;;
+    -*)
+        echo "✖ option inconnue : $1 (devzone --help)" >&2
+        exit 1
+        ;;
+    *) creer "$1" ;;
+esac

package/desinstaller.sh

@@ -0,0 +1,132 @@
+#!/usr/bin/env bash
+# Désinstallation complète de devzone, lancée sur l'hôte :
+#   make desinstaller                     tout, après confirmation
+#   make desinstaller GARDER=connexions   tout sauf les connexions (gh, git,
+#                                         Claude Code, opencode, modules)
+# Supprime : conteneur, image, volume du Docker interne (images et clusters
+# kind), volumes devzone-*, metrics-server installé par devzone sur les
+# clusters locaux de l'hôte. Ne touche jamais : workspace/ (tes projets),
+# l'image de base, un metrics-server que devzone n'a pas installé.
+# Sans terminal : CONFIRMER=oui.
+set -euo pipefail
+
+ICI="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ETAT="$ICI/.devzone.etat"
+GARDER="${GARDER:-}"
+CONNEXIONS=(gh git claude opencode-config opencode-data config)
+LOCAUX='^(kind-.*|docker-desktop|rancher-desktop|orbstack|minikube)$'
+
+case "$GARDER" in "" | connexions) ;; *)
+    echo "GARDER : valeur inconnue : $GARDER (seule valeur : connexions)" >&2
+    exit 1
+    ;;
+esac
+
+# --- Inventaire --------------------------------------------------------------
+echo "▶ Inventaire (dossier $ICI)"
+conteneurs=() images=() dind=()
+# Étiquette posée avec le chemin tel qu'ouvert (VS Code, make) : chemin
+# logique ou physique selon les liens symboliques ; les deux sont cherchés
+ids="$(for chemin in "$ICI" "$(cd "$ICI" && pwd -P)"; do docker ps -aq --filter "label=devcontainer.local_folder=$chemin"; done | sort -u)"
+for id in $ids; do
+    conteneurs+=("$id")
+    images+=("$(docker inspect "$id" --format '{{.Config.Image}}')")
+    v="$(docker inspect "$id" --format '{{range .Mounts}}{{if eq .Destination "/var/lib/docker"}}{{.Name}}{{end}}{{end}}')"
+    [ -z "$v" ] || dind+=("$v")
+done
+# Conteneur déjà supprimé par make down : image et Docker interne notés alors
+if [ "${#conteneurs[@]}" -eq 0 ] && [ -f "$ETAT" ]; then
+    # Lu, jamais exécuté
+    IMAGE="$(sed -n 's/^IMAGE=//p' "$ETAT")"
+    DIND="$(sed -n 's/^DIND=//p' "$ETAT")"
+    [ -z "${IMAGE:-}" ] || ! docker image inspect "$IMAGE" >/dev/null 2>&1 || images+=("$IMAGE")
+    [ -z "${DIND:-}" ] || ! docker volume inspect "$DIND" >/dev/null 2>&1 || dind+=("$DIND")
+fi
+
+# Volumes : noms exacts de devcontainer.json (préfixe DEVZONE_VOLUMES compris)
+volumes=() gardes=()
+config="$(npx -y @devcontainers/cli read-configuration --workspace-folder "$ICI" 2>/dev/null)" || {
+    echo "✖ lecture de .devcontainer/devcontainer.json impossible (npx @devcontainers/cli)" >&2
+    exit 1
+}
+# shellcheck disable=SC2016 # ${m.source} : gabarit JavaScript, pas du shell
+for nom in $(node -e '
+    const c = JSON.parse(require("fs").readFileSync(0, "utf8")).configuration;
+    for (const m of c.mounts || []) {
+        const s = typeof m === "string" ? m : `source=${m.source},type=${m.type}`;
+        if (/type=volume/.test(s)) { const r = /source=([^,]+)/.exec(s); if (r) console.log(r[1]); }
+    }' <<<"$config"); do
+    docker volume inspect "$nom" >/dev/null 2>&1 || continue
+    garde=false
+    if [ "$GARDER" = connexions ]; then
+        for c in "${CONNEXIONS[@]}"; do [[ "$nom" == *-"$c" ]] && garde=true; done
+    fi
+    if [ "$garde" = true ]; then gardes+=("$nom"); else volumes+=("$nom"); fi
+done
+
+# metrics-server installé par devzone (étiquette devzone=installe), sur les
+# clusters locaux de l'hôte joignables ; jamais un autre
+metrics=() etrangers=()
+if command -v kubectl >/dev/null 2>&1; then
+    for ctx in $(kubectl config get-contexts -o name 2>/dev/null | grep -E "$LOCAUX" || true); do
+        k=(kubectl --context "$ctx" --request-timeout=5s)
+        "${k[@]}" get --raw /readyz >/dev/null 2>&1 || continue
+        marque="$("${k[@]}" -n kube-system get deployment metrics-server -o jsonpath='{.metadata.labels.devzone}' 2>/dev/null)" || continue
+        if [ "$marque" = installe ]; then metrics+=("$ctx"); else etrangers+=("$ctx"); fi
+    done
+fi
+
+# --- Confirmation ------------------------------------------------------------
+afficher() { if [ "$#" -eq 0 ]; then echo "  (rien)"; else printf '  %s\n' "$@"; fi; }
+echo "À supprimer :"
+echo " conteneur(s) :"; afficher ${conteneurs[@]+"${conteneurs[@]}"}
+echo " image(s) :"; afficher ${images[@]+"${images[@]}"}
+echo " Docker interne (images et clusters kind) :"; afficher ${dind[@]+"${dind[@]}"}
+echo " volumes :"; afficher ${volumes[@]+"${volumes[@]}"}
+echo " metrics-server installé par devzone, sur :"; afficher ${metrics[@]+"${metrics[@]}"}
+[ "${#gardes[@]}" -eq 0 ] || { echo "Gardés (GARDER=connexions) :"; printf '  %s\n' "${gardes[@]}"; }
+if [ "${#conteneurs[@]}" -eq 0 ] && [ ! -f "$ETAT" ] && [ "${#images[@]}" -eq 0 ]; then
+    echo "ℹ Aucun conteneur ni trace de l'image : si un make down d'une version antérieure les a laissés,"
+    echo "  les retrouver avec : docker images 'vsc-$(basename "$ICI")-*' ; docker volume ls -q -f name=dind-var-lib-docker"
+fi
+
+total=$((${#conteneurs[@]} + ${#images[@]} + ${#dind[@]} + ${#volumes[@]} + ${#metrics[@]}))
+if [ "$total" -eq 0 ]; then
+    echo "✔ Rien à supprimer."
+else
+    if [ "${CONFIRMER:-}" != oui ]; then
+        if [ ! -t 0 ]; then
+            echo "✖ Confirmation impossible sans terminal : CONFIRMER=oui make desinstaller" >&2
+            exit 1
+        fi
+        read -r -p "Supprimer définitivement ? Taper oui : " reponse
+        [ "$reponse" = oui ] || { echo "Abandon : rien n'a été supprimé."; exit 0; }
+    fi
+
+    # --- Suppression ---------------------------------------------------------
+    for id in ${conteneurs[@]+"${conteneurs[@]}"}; do docker rm -f "$id" >/dev/null && echo "✔ conteneur supprimé : $id"; done
+    for i in ${images[@]+"${images[@]}"}; do docker rmi "$i" >/dev/null && echo "✔ image supprimée : $i"; done
+    for v in ${dind[@]+"${dind[@]}"} ${volumes[@]+"${volumes[@]}"}; do docker volume rm "$v" >/dev/null && echo "✔ volume supprimé : $v"; done
+    if [ "${#metrics[@]}" -gt 0 ]; then
+        version="$(sed -n 's/^VERSION=//p' "$ICI/.devcontainer/metrics-server.sh")"
+        manifeste="https://github.com/kubernetes-sigs/metrics-server/releases/download/${version}/components.yaml"
+        for ctx in "${metrics[@]}"; do
+            kubectl --context "$ctx" delete -f "$manifeste" --ignore-not-found >/dev/null &&
+                echo "✔ metrics-server retiré : $ctx"
+        done
+    fi
+fi
+rm -f "$ICI/.devzone.log" "$ETAT"
+
+# --- Ce qui reste ------------------------------------------------------------
+echo
+echo "Non touché (à retirer toi-même si tu le souhaites) :"
+echo "  workspace/ : tes projets"
+for ctx in ${etrangers[@]+"${etrangers[@]}"}; do
+    echo "  metrics-server sur $ctx : non installé par devzone (kubectl --context $ctx -n kube-system delete deployment metrics-server)"
+done
+command -v kubectl >/dev/null 2>&1 || echo "  metrics-server : kubectl absent de l'hôte, clusters de l'hôte non vérifiés"
+echo "  image de base mcr.microsoft.com/devcontainers/base (partagée) : docker rmi mcr.microsoft.com/devcontainers/base:ubuntu-24.04"
+echo "  cache npx du CLI devcontainer : ~/.npm/_npx"
+echo "  autorisation « GitHub CLI » sur ton compte : GitHub → Settings → Applications"
+echo "  ce dossier : $ICI"

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "devzone",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.5.0",
+  "description": "Zone de dev conteneurisée : Java, Node, Python, Docker, Kubernetes et outils repowarden, dans un devcontainer",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SimBienvenueHoulBoumi/devzone.git"
+  },
+  "homepage": "https://github.com/SimBienvenueHoulBoumi/devzone#readme",
+  "bugs": "https://github.com/SimBienvenueHoulBoumi/devzone/issues",
+  "keywords": [
+    "devcontainer",
+    "docker",
+    "kubernetes",
+    "repowarden",
+    "environnement"
+  ],
+  "bin": {
+    "devzone": "bin/devzone"
+  },
+  "files": [
+    "bin/",
+    ".devcontainer/",
+    "Makefile",
+    ".gitattributes",
+    "desinstaller.sh",
+    "README.md",
+    "LICENSE"
+  ]
+}