repowarden 0.0.0-stage → 4.1.0

package/hooks/lang/node.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+# JavaScript / TypeScript (React, Next.js, Vue, Angular, Nest…) : prettier, <pm> test
+# Extensions de code (analyse du code mort) : les autres (md, yml, json…) ne
+# sont rattachées à node que pour le formatage
+# shellcheck disable=SC2034 # lu par deadcode.sh (${PLUGIN}_CODE_EXT)
+NODE_CODE_EXT='\.(js|jsx|ts|tsx|mjs|cjs|mts|cts|vue|svelte|astro)$'
+register node "package.json" '\.(js|jsx|ts|tsx|mjs|cjs|mts|cts|vue|svelte|astro|json|jsonc|css|scss|less|html|md|mdx|ya?ml|graphql)$' standalone
+
+# Gestionnaire de paquets d'après le lockfile (y compris à la racine d'un monorepo)
+node_pm() {
+    if find_up pnpm-lock.yaml >/dev/null; then echo pnpm
+    elif find_up yarn.lock >/dev/null; then echo yarn
+    elif find_up bun.lockb >/dev/null || find_up bun.lock >/dev/null; then echo bun
+    else echo npm
+    fi
+}
+
+node_format() {
+    local prettier
+    prettier="$(find_up node_modules/.bin/prettier || command -v prettier || true)"
+    [ -n "$prettier" ] || { tool_missing "Node : prettier introuvable (npm i -D prettier), formatage ignoré."; return 0; }
+    step_t lang.node.1
+    "$prettier" --write --ignore-unknown --log-level warn "$@"
+}
+
+node_test() {
+    has node || { warn "Node : node absent, tests ignorés."; return 0; }
+    # Ignore le script "test" par défaut généré par npm init
+    if ! node -e 'const t=(require("./package.json").scripts||{}).test; process.exit(t && !/no test specified/.test(t) ? 0 : 1)'; then
+        info_t lang.node.2
+        return 0
+    fi
+    local pm; pm="$(node_pm)"
+    has "$pm" || { warn "Node : $pm absent, tests ignorés."; return 0; }
+    step_t lang.node.3 "$pm"
+    case "$pm" in
+        bun) bun run test ;;
+        npm) npm test --silent ;;
+        *) "$pm" test ;;
+    esac
+}
+
+# Code mort : TypeScript (variables, paramètres, imports inutilisés, code
+# inaccessible : prouvé) ; knip s'il est installé dans le projet (fichiers,
+# exports, dépendances non référencés : candidats)
+node_deadcode() {
+    local ran=""
+    if [ -f tsconfig.json ] && [ -x node_modules/.bin/tsc ]; then
+        ran=1
+        node_modules/.bin/tsc --noEmit -p . --noUnusedLocals --noUnusedParameters \
+            --allowUnreachableCode false --pretty false 2>/dev/null |
+            sed -nE 's/^(.+)\(([0-9]+),[0-9]+\): error (TS6133|TS6138|TS6192|TS6196|TS6198|TS7027): (.*)$/prouve\t\1\t\2\t\4/p'
+    fi
+    if [ -x node_modules/.bin/knip ] && has node; then
+        ran=1
+        _tr dc.knip_file
+        local m_file="$_T"
+        _tr dc.knip_export
+        local m_export="$_T"
+        _tr dc.knip_dep
+        local m_dep="$_T"
+        node_modules/.bin/knip --reporter json --no-progress 2>/dev/null |
+            M_FILE="$m_file" M_EXPORT="$m_export" M_DEP="$m_dep" node -e '
+                let r; try { r = JSON.parse(require("fs").readFileSync(0, "utf8")); } catch { process.exit(0); }
+                const out = (f, l, m) => console.log(["candidat", f, l, m].join("\t"));
+                for (const f of r.files || []) out(f, 0, process.env.M_FILE);
+                for (const i of r.issues || []) {
+                    for (const k of ["exports", "types", "nsExports", "nsTypes"])
+                        for (const e of i[k] || []) out(i.file, e.line || 0, process.env.M_EXPORT + " " + e.name);
+                    for (const k of ["dependencies", "devDependencies"])
+                        for (const d of i[k] || []) out(i.file, 0, process.env.M_DEP + " " + d.name);
+                }'
+    fi
+    [ -n "$ran" ] || deadcode_tool_missing "JavaScript / TypeScript" "typescript / knip"
+}

package/hooks/lang/packer.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# Packer : packer fmt ; validation syntaxique au push / en CI
+register packer "*.pkr.hcl" '\.(pkr|pkrvars)\.hcl$' standalone
+
+packer_format() {
+    has packer || { tool_missing "Packer : packer absent, formatage ignoré."; return 0; }
+    step_t lang.packer.1
+    local f
+    for f in "$@"; do packer fmt "$f" >/dev/null || return 1; done
+}
+
+packer_test() {
+    has packer || { warn "Packer : packer absent, validation ignorée."; return 0; }
+    step_t lang.packer.2
+    packer validate -syntax-only .
+}

package/hooks/lang/php.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# PHP (Laravel, Symfony…) : pint / php-cs-fixer, composer test / artisan / pest / phpunit
+register php "composer.json" '\.php$'
+
+php_format() {
+    if [ -x vendor/bin/pint ]; then step_t lang.php.1; vendor/bin/pint -q "$@"
+    elif [ -x vendor/bin/php-cs-fixer ]; then step "PHP : php-cs-fixer"; vendor/bin/php-cs-fixer fix -q "$@"
+    elif has php-cs-fixer; then step "PHP : php-cs-fixer"; php-cs-fixer fix -q "$@"
+    else tool_missing "PHP : ni pint ni php-cs-fixer, formatage ignoré."
+    fi
+}
+
+php_test() {
+    if grep -q '"test"[[:space:]]*:' composer.json && has composer; then step_t lang.php.2; composer test
+    elif [ -f artisan ]; then step "PHP : artisan test"; php artisan test
+    elif [ -x vendor/bin/pest ]; then step "PHP : pest"; vendor/bin/pest
+    elif [ -x vendor/bin/phpunit ]; then step "PHP : phpunit"; vendor/bin/phpunit
+    else info "PHP : aucun lanceur de tests trouvé (composer install ?)."
+    fi
+}

package/hooks/lang/python.sh

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+# Python (Django, FastAPI, Flask, scripts…) : ruff/black, pytest ou manage.py test
+# Les outils du projet (.venv, uv) sont prioritaires : même version pour tous.
+register python "pyproject.toml setup.py setup.cfg requirements.txt Pipfile manage.py" '\.pyi?$' standalone
+
+# Exécute dans l'environnement du projet (uv, poetry, pipenv, .venv)
+python_run() {
+    if [ -f uv.lock ] && has uv; then uv run --no-sync "$@"
+    elif [ -f poetry.lock ] && has poetry; then poetry run "$@"
+    elif [ -f Pipfile.lock ] && has pipenv; then pipenv run "$@"
+    elif [ -d .venv/bin ]; then PATH="$PWD/.venv/bin:$PATH" "$@"
+    elif [ -d .venv/Scripts ]; then PATH="$PWD/.venv/Scripts:$PATH" "$@"
+    else "$@"
+    fi
+}
+
+# Vrai si l'outil $1 est disponible (dans le projet, sinon sur le poste)
+python_has() { python_run "$1" --version >/dev/null 2>&1; }
+
+python_format() {
+    if python_has ruff; then step_t lang.python.1; python_run ruff format -q "$@"
+    elif python_has black; then step "Python : black"; python_run black -q "$@"
+    else tool_missing "Python : ni ruff ni black installé, formatage ignoré."
+    fi
+}
+
+# Vrai si le projet contient des tests : un requirements.txt seul (outils de
+# documentation, scripts) ne doit pas exiger pytest.
+python_has_tests() {
+    [ -f manage.py ] && return 0
+    # -quit : premier fichier trouvé suffit (pas de tube vers grep -q : SIGPIPE)
+    [ -n "$(find . \( -name node_modules -o -name .venv -o -name .git -o -name site-packages \) -prune -o \
+        \( -name 'test_*.py' -o -name '*_test.py' -o -name conftest.py \) -print -quit 2>/dev/null)" ]
+}
+
+python_test() {
+    local rc=0 cache
+    # Cache de bytecode neuf : Python réutilise un .pyc si la source a même taille
+    # et même date à la seconde près — fréquent quand le hook met de côté puis
+    # restaure des fichiers. Sans ça, les tests tourneraient sur l'ancien code.
+    cache="$(mktemp -d)"
+    export PYTHONPYCACHEPREFIX="$cache"
+    # Django sans pytest-django : runner intégré
+    if [ -f manage.py ] && ! grep -qs pytest-django pyproject.toml requirements*.txt setup.cfg Pipfile; then
+        step_t lang.python.2
+        python_run python manage.py test || rc=$?
+        rm -rf "$cache"
+        return "$rc"
+    fi
+    if ! python_has_tests; then info_t lang.python.3; rm -rf "$cache"; return 0; fi
+    if ! python_has pytest; then warn_t lang.python.4; rm -rf "$cache"; return 0; fi
+    step_t lang.python.5
+    # Racine du projet importable (comme « python -m pytest ») : tests/ importe
+    # le paquet sans installation ni conftest.py
+    PYTHONPATH="$PWD${PYTHONPATH:+:$PYTHONPATH}" python_run pytest -q -p no:cacheprovider || rc=$?
+    rm -rf "$cache"
+    # 5 = aucun test collecté : pas une erreur
+    if [ "$rc" -eq 5 ]; then info_t lang.python.6; return 0; fi
+    return "$rc"
+}
+
+# Code mort : ruff (imports et variables inutilisés, redéfinitions : prouvé) ;
+# vulture (confiance 100 % : prouvé, en dessous : candidat — les frameworks
+# appellent des fonctions par leur nom)
+python_deadcode() {
+    local ran=""
+    if python_has ruff; then
+        ran=1
+        python_run ruff check --select F401,F811,F841 --output-format concise --quiet --exit-zero . 2>/dev/null |
+            sed -nE 's/^(.+):([0-9]+):[0-9]+: F[0-9]+ (\[\*\] )?(.*)$/prouve\t\1\t\2\t\4/p'
+    fi
+    if python_has vulture; then
+        ran=1
+        python_run vulture . --min-confidence 60 --exclude ".venv,venv,node_modules,build,dist,site-packages" 2>/dev/null |
+            sed -nE -e 's/^(.+):([0-9]+): (.*) \(100% confidence\)$/prouve\t\1\t\2\t\3/p' \
+                -e 's/^(.+):([0-9]+): (.*) \(([0-9]+)% confidence\)$/candidat\t\1\t\2\t\3 (\4 %)/p'
+    fi
+    [ -n "$ran" ] || deadcode_tool_missing Python "ruff / vulture"
+}

package/hooks/lang/ruby.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Ruby (Rails…) : rubocop -a / standardrb, rails test / rspec / rake test
+register ruby "Gemfile" '(\.(rb|rake|gemspec)|(^|/)(Rakefile|Gemfile))$'
+
+ruby_format() {
+    if grep -qs '^    rubocop ' Gemfile.lock; then
+        step_t lang.ruby.1
+        bundle exec rubocop -a --format quiet --fail-level F "$@"
+    elif grep -qs '^    standard ' Gemfile.lock; then
+        step_t lang.ruby.2
+        bundle exec standardrb --fix "$@" || true # les offenses non corrigeables ne bloquent pas
+    else
+        tool_missing "Ruby : ni rubocop ni standard dans le Gemfile, formatage ignoré."
+    fi
+}
+
+ruby_test() {
+    has bundle || { warn "Ruby : bundler absent, tests ignorés."; return 0; }
+    if [ -x bin/rails ]; then step_t lang.ruby.3; bin/rails test
+    elif [ -d spec ] && grep -qs '^    rspec' Gemfile.lock; then step "Ruby : rspec"; bundle exec rspec
+    elif [ -f Rakefile ]; then step "Ruby : rake test"; bundle exec rake test
+    else info "Ruby : aucun lanceur de tests trouvé."
+    fi
+}

package/hooks/lang/rust.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# Rust : rustfmt (fichiers stagés uniquement), cargo test
+register rust "Cargo.toml" '\.rs$' standalone outermost
+
+rust_format() {
+    has rustfmt || { tool_missing "Rust : rustfmt absent, formatage ignoré."; return 0; }
+    local edition
+    edition="$(grep -hsE '^[[:space:]]*edition[[:space:]]*=' Cargo.toml ./*/Cargo.toml | grep -oE '20[0-9]{2}' | sed -n 1p)"
+    step_t lang.rust.1
+    rustfmt --edition "${edition:-2021}" "$@"
+}
+
+rust_test() {
+    has cargo || { warn "Rust : cargo absent, tests ignorés."; return 0; }
+    step_t lang.rust.2
+    cargo test --quiet
+}

package/hooks/lang/shell.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+# Scripts shell : shfmt (respecte .editorconfig, sinon indentation 4 espaces)
+register shell "" '\.(sh|bash)$' standalone
+
+shell_format() {
+    has shfmt || { tool_missing "Shell : shfmt absent, formatage ignoré."; return 0; }
+    step_t lang.shell.1
+    if find_up .editorconfig >/dev/null; then shfmt -w "$@"; else shfmt -w -i 4 -ci "$@"; fi
+}

package/hooks/lang/swift.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Swift (SwiftPM) : swift-format / SwiftFormat si une config existe, swift test
+# Pas de style canonique en Swift : formatage seulement avec .swift-format ou .swiftformat
+register swift "Package.swift" '\.swift$' standalone
+
+swift_format() {
+    if find_up .swift-format >/dev/null && swift format --version >/dev/null 2>&1; then
+        step_t lang.swift.1; swift format --in-place "$@"
+    elif find_up .swiftformat >/dev/null && has swiftformat; then
+        step_t lang.swift.2; swiftformat --quiet "$@"
+    else
+        tool_missing "Swift : pas de .swift-format/.swiftformat (ou outil absent), formatage ignoré."
+    fi
+}
+
+swift_test() {
+    [ -d Tests ] || { info "Swift : pas de dossier Tests/."; return 0; }
+    has swift || { warn "Swift : swift absent, tests ignorés."; return 0; }
+    step_t lang.swift.3; swift test
+}

package/hooks/lang/tasks.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# Projets sans langage reconnu : cible "test" d'un Makefile, justfile ou Taskfile
+register tasks "Makefile makefile GNUmakefile justfile Justfile .justfile Taskfile.yml Taskfile.yaml" '^$' fallback
+
+tasks_test() {
+    if compgen -G "[Mm]akefile" >/dev/null || [ -f GNUmakefile ]; then
+        if has make && make -n test >/dev/null 2>&1; then step_t lang.tasks.1; make test; return; fi
+    fi
+    if compgen -G "*ustfile" >/dev/null || [ -f .justfile ]; then
+        if has just && just --show test >/dev/null 2>&1; then step_t lang.tasks.2; just test; return; fi
+    fi
+    if compgen -G "Taskfile.y*ml" >/dev/null; then
+        if has task && grep -q '^\* test:' <<<"$(task --list-all 2>/dev/null)"; then step_t lang.tasks.3; task test; return; fi
+    fi
+    info_t lang.tasks.4
+}

package/hooks/lang/terraform.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# Terraform / OpenTofu : fmt ; init (sans backend) + validate + tflint au push / en CI
+register terraform "*.tf" '\.(tf|tfvars|tftest\.hcl)$' standalone
+
+terraform_bin() { command -v terraform || command -v tofu || true; }
+
+terraform_format() {
+    local bin
+    bin="$(terraform_bin)"
+    [ -n "$bin" ] || { tool_missing "Terraform : terraform/tofu absent, formatage ignoré."; return 0; }
+    step_t lang.terraform.1
+    "$bin" fmt "$@" >/dev/null
+}
+
+terraform_test() {
+    local bin
+    bin="$(terraform_bin)"
+    [ -n "$bin" ] || { warn "Terraform : terraform/tofu absent, validation ignorée."; return 0; }
+    step_t lang.terraform.2
+    # Providers partagés entre modules et entre lancements
+    TF_PLUGIN_CACHE_DIR="${TF_PLUGIN_CACHE_DIR:-$(cache_dir terraform-plugins)}" \
+        "$bin" init -backend=false -input=false -no-color >/dev/null || return 1
+    "$bin" validate -no-color || return 1
+    if has tflint; then
+        step_t lang.terraform.3
+        tflint --init >/dev/null 2>&1
+        tflint --no-color || return 1
+    fi
+}