xgem-cli 2.0.0-alpha.14 → 2.0.0-alpha.16

package/lib/toolchain.sh

@@ -0,0 +1,450 @@
+#!/bin/bash
+# xgem toolchain layer: finds tools where version managers actually put them,
+# offers to install missing ones, and reports/applies updates.
+# Kept bash 3.2 compatible (macOS default): no associative arrays.
+# Depends on lib/logger.sh, lib/utils.sh.
+
+XGEM_CACHE_DIR="${XGEM_CACHE_DIR:-$HOME/.xgem/cache}"
+: "${XGEM_NO_NETWORK:=0}"
+
+TOOL_DIR=""
+TOOL_PATH=""
+TOOL_MANAGER=""
+TOOL_ON_PATH=0
+
+_tool_canon() {
+    case "$1" in
+        npm|npx|corepack) echo node ;;
+        pip|pip3|python) echo python3 ;;
+        rustc|rustup)    echo cargo ;;
+        *)               echo "$1" ;;
+    esac
+}
+
+tool_known() {
+    case "$(_tool_canon "$1")" in
+        flutter|dart|node|python3|go|cargo|docker|git|gh|swift|fvm) return 0 ;;
+        *) return 1 ;;
+    esac
+}
+
+tool_display() {
+    case "$1" in
+        flutter) echo "Flutter SDK" ;;
+        dart)    echo "Dart SDK" ;;
+        node)    echo "Node.js" ;;
+        python3) echo "Python 3" ;;
+        go)      echo "Go" ;;
+        cargo)   echo "Rust (cargo)" ;;
+        docker)  echo "Docker" ;;
+        git)     echo "Git" ;;
+        gh)      echo "GitHub CLI" ;;
+        swift)   echo "Swift" ;;
+        fvm)     echo "FVM (Flutter Version Management)" ;;
+        *)       echo "$1" ;;
+    esac
+}
+
+tool_url() {
+    case "$1" in
+        flutter|dart) echo "https://docs.flutter.dev/get-started/install" ;;
+        node)    echo "https://nodejs.org/en/download" ;;
+        python3) echo "https://www.python.org/downloads/" ;;
+        go)      echo "https://go.dev/dl/" ;;
+        cargo)   echo "https://www.rust-lang.org/tools/install" ;;
+        docker)  echo "https://www.docker.com/products/docker-desktop/" ;;
+        git)     echo "https://git-scm.com/downloads" ;;
+        gh)      echo "https://cli.github.com" ;;
+        swift)   echo "https://www.swift.org/install/" ;;
+        fvm)     echo "https://fvm.app/documentation/getting-started/installation" ;;
+    esac
+}
+
+# fw_required_tool <framework> -> the tool that framework's commands need.
+fw_required_tool() {
+    case "$1" in
+        flutter) echo flutter ;;
+        node|react|vue|angular|next) echo node ;;
+        python) echo python3 ;;
+        go) echo go ;;
+        rust) echo cargo ;;
+        swift) echo swift ;;
+        docker) echo docker ;;
+    esac
+}
+
+_tool_pretty() {
+    case "$1" in
+        "$HOME"/*) printf '~%s' "${1#"$HOME"}" ;;
+        *) printf '%s' "$1" ;;
+    esac
+}
+
+_tool_find_up() {
+    local dir=$PWD
+    while [ -n "$dir" ]; do
+        [ "$dir" = "$HOME" ] && [ "$PWD" != "$HOME" ] && break
+        [ -e "$dir/$1" ] && { echo "$dir/$1"; return 0; }
+        [ "$dir" = "/" ] && break
+        dir=$(dirname "$dir")
+    done
+    return 1
+}
+
+# tool_pin <tool> -> the version this project pins for it, if any.
+tool_pin() {
+    local f v="" key
+    case "$1" in
+        flutter|dart)
+            if f=$(_tool_find_up .fvmrc); then
+                v=$(grep -oE '"flutter"[[:space:]]*:[[:space:]]*"[^"]+"' "$f" | sed -E 's/.*:[[:space:]]*"([^"]+)"/\1/')
+            elif f=$(_tool_find_up .fvm/fvm_config.json); then
+                v=$(grep -oE '"flutterSdkVersion"[[:space:]]*:[[:space:]]*"[^"]+"' "$f" | sed -E 's/.*:[[:space:]]*"([^"]+)"/\1/')
+            fi
+            key=flutter
+            ;;
+        node)
+            if f=$(_tool_find_up .nvmrc); then
+                v=$(tr -d '[:space:]' < "$f")
+                v=${v#v}
+            fi
+            key=nodejs
+            ;;
+        python3) key=python ;;
+        go)      key=golang ;;
+        cargo)   key=rust ;;
+        *)       key="" ;;
+    esac
+    if [ -z "$v" ] && [ -n "$key" ] && f=$(_tool_find_up .tool-versions); then
+        v=$(awk -v k="$key" '$1==k {print $2; exit}' "$f")
+    fi
+    echo "$v"
+}
+
+_tool_fvm_roots() {
+    [ -n "${FVM_CACHE_PATH:-}" ] && echo "$FVM_CACHE_PATH"
+    [ -n "${FVM_HOME:-}" ] && echo "$FVM_HOME"
+    echo "$HOME/fvm"
+    echo "$HOME/.fvm"
+    echo "$HOME/.fvm_flutter"
+}
+
+_tool_nvm_candidate() {
+    local root=${NVM_DIR:-$HOME/.nvm} pin want v=""
+    [ -d "$root/versions/node" ] || return 0
+    pin=$(tool_pin node)
+    if [[ "$pin" =~ ^[0-9] ]]; then
+        v=$(ls -1 "$root/versions/node" | grep -E "^v${pin}" | sort -V | tail -1)
+    fi
+    if [ -z "$v" ] && [ -f "$root/alias/default" ]; then
+        want=$(tr -d '[:space:]' < "$root/alias/default")
+        want=${want#v}
+        [[ "$want" =~ ^[0-9] ]] && v=$(ls -1 "$root/versions/node" | grep -E "^v${want}" | sort -V | tail -1)
+    fi
+    [ -z "$v" ] && v=$(ls -1 "$root/versions/node" | sort -V | tail -1)
+    [ -n "$v" ] && printf '%s/versions/node/%s/bin\tnvm\n' "$root" "$v"
+}
+
+# _tool_candidates <canonical tool> -> "dir<TAB>manager" lines, best first.
+_tool_candidates() {
+    local canon=$1 root pin d v
+    case "$canon" in
+        flutter|dart)
+            pin=$(tool_pin flutter)
+            if d=$(_tool_find_up .fvm/flutter_sdk) && [ -d "$d/bin" ]; then
+                printf '%s/bin\tfvm\n' "$d"
+            fi
+            while IFS= read -r root; do
+                [ -n "$pin" ] && printf '%s/versions/%s/bin\tfvm\n' "$root" "$pin"
+            done < <(_tool_fvm_roots)
+            printf '%s/.fvm/flutter_sdk/bin\tfvm\n' "$HOME"
+            while IFS= read -r root; do
+                printf '%s/default/bin\tfvm\n' "$root"
+            done < <(_tool_fvm_roots)
+            while IFS= read -r root; do
+                v=$(ls -1 "$root/versions" 2>/dev/null | sort -V | tail -1)
+                [ -n "$v" ] && printf '%s/versions/%s/bin\tfvm\n' "$root" "$v"
+            done < <(_tool_fvm_roots)
+            printf '%s/.puro/envs/stable/flutter/bin\tpuro\n' "$HOME"
+            printf '%s/development/flutter/bin\tother\n' "$HOME"
+            printf '%s/flutter/bin\tother\n' "$HOME"
+            ;;
+        node)
+            _tool_nvm_candidate
+            printf '%s/.local/share/fnm/aliases/default/bin\tfnm\n' "$HOME"
+            printf '%s/Library/Application Support/fnm/aliases/default/bin\tfnm\n' "$HOME"
+            printf '%s/.volta/bin\tvolta\n' "$HOME"
+            ;;
+        python3) printf '%s/.pyenv/shims\tpyenv\n' "$HOME" ;;
+        go)      printf '/usr/local/go/bin\tother\n' ;;
+        cargo)   printf '%s/.cargo/bin\trustup\n' "$HOME" ;;
+        docker)
+            printf '/Applications/Docker.app/Contents/Resources/bin\tother\n'
+            printf '%s/.docker/bin\tother\n' "$HOME"
+            ;;
+    esac
+    printf '%s/.asdf/shims\tasdf\n' "$HOME"
+    printf '%s/.local/share/mise/shims\tmise\n' "$HOME"
+    printf '/opt/homebrew/bin\tbrew\n'
+    printf '/usr/local/bin\tsystem\n'
+}
+
+_tool_manager_of() {
+    case "$1" in
+        */.nvm/*) echo nvm ;;
+        */fvm/*|*/.fvm/*|*/.fvm_flutter/*) echo fvm ;;
+        /opt/homebrew/*|*/Cellar/*|/home/linuxbrew/*) echo brew ;;
+        */.cargo/*) echo rustup ;;
+        */.pyenv/*) echo pyenv ;;
+        */.asdf/*) echo asdf ;;
+        */mise/*) echo mise ;;
+        */.volta/*) echo volta ;;
+        */.puro/*) echo puro ;;
+        /usr/bin/*|/bin/*) echo system ;;
+        *) echo other ;;
+    esac
+}
+
+# tool_resolve <command> -> 0 if found; sets TOOL_PATH, TOOL_DIR,
+# TOOL_MANAGER, TOOL_ON_PATH. Never calls has_cmd (no recursion).
+tool_resolve() {
+    local cmd=$1 canon dir via p d
+    canon=$(_tool_canon "$cmd")
+    TOOL_DIR=""; TOOL_PATH=""; TOOL_MANAGER=""; TOOL_ON_PATH=0
+
+    p=$(command -v "$cmd" 2>/dev/null)
+    if [ -n "$p" ] && [ -x "$p" ]; then
+        TOOL_PATH=$p
+        TOOL_DIR=$(dirname "$p")
+        TOOL_ON_PATH=1
+        TOOL_MANAGER=$(_tool_manager_of "$p")
+        return 0
+    fi
+
+    while IFS=$'\t' read -r dir via; do
+        [ -x "$dir/$cmd" ] || continue
+        TOOL_PATH="$dir/$cmd"
+        TOOL_DIR=$dir
+        TOOL_MANAGER=$via
+        return 0
+    done < <(_tool_candidates "$canon")
+
+    if [ "$canon" = "flutter" ] || [ "$canon" = "dart" ]; then
+        if [ "$(command -v fvm 2>/dev/null)" ]; then
+            d=$(fvm api context 2>/dev/null | grep -oE '"fvmDir"[[:space:]]*:[[:space:]]*"[^"]+"' | sed -E 's/.*"([^"]+)"$/\1/')
+            for p in "$d/default/bin" "$d/versions/$(ls -1 "$d/versions" 2>/dev/null | sort -V | tail -1)/bin"; do
+                [ -x "$p/$cmd" ] || continue
+                TOOL_PATH="$p/$cmd"; TOOL_DIR=$p; TOOL_MANAGER=fvm
+                return 0
+            done
+        fi
+    fi
+    return 1
+}
+
+tool_activate() {
+    [ "$TOOL_ON_PATH" = "1" ] && return 0
+    [ -n "$TOOL_DIR" ] || return 1
+    PATH="$TOOL_DIR:$PATH"
+    export PATH
+    hash -r
+}
+
+# tool_version_of <canonical tool> -> installed version of TOOL_PATH.
+tool_version_of() {
+    local canon=$1 flag=--version sdk out
+    case "$canon" in
+        flutter)
+            sdk="$(dirname "$TOOL_PATH")/.."
+            if [ -f "$sdk/bin/cache/flutter.version.json" ]; then
+                out=$(grep -oE '"frameworkVersion"[[:space:]]*:[[:space:]]*"[^"]+"' "$sdk/bin/cache/flutter.version.json" | sed -E 's/.*"([^"]+)"$/\1/')
+                [ -n "$out" ] && { echo "$out"; return 0; }
+            fi
+            ;;
+        go) flag=version ;;
+        swift)
+            "$TOOL_PATH" --version 2>&1 | grep -oE 'Swift version [0-9]+(\.[0-9]+)*' | head -1 | grep -oE '[0-9]+(\.[0-9]+)*'
+            return 0
+            ;;
+    esac
+    "$TOOL_PATH" $flag 2>&1 | head -3 | grep -oE '[0-9]+(\.[0-9]+)+' | head -1
+}
+
+_tool_ver_lt() {
+    [ "$1" != "$2" ] && [ "$(printf '%s\n%s\n' "$1" "$2" | sort -V | head -1)" = "$1" ]
+}
+
+_tool_curl() {
+    has_cmd curl || return 1
+    curl -fsSL --connect-timeout 3 -m 8 "$1" 2>/dev/null
+}
+
+_tool_flutter_stable_from_json() {
+    if command -v python3 >/dev/null 2>&1; then
+        python3 -c 'import sys,json;d=json.load(sys.stdin);h=d["current_release"]["stable"];print(next(r["version"] for r in d["releases"] if r["hash"]==h and r["channel"]=="stable"))' 2>/dev/null
+    elif command -v node >/dev/null 2>&1; then
+        node -e 'let s="";process.stdin.on("data",c=>s+=c).on("end",()=>{const d=JSON.parse(s);const h=d.current_release.stable;console.log(d.releases.find(r=>r.hash===h&&r.channel==="stable").version)})' 2>/dev/null
+    fi
+}
+
+_tool_brew_latest() {
+    local formula=$1
+    case "$1" in python3) formula=python@3 ;; esac
+    HOMEBREW_NO_AUTO_UPDATE=1 HOMEBREW_NO_ANALYTICS=1 brew info --json=v2 "$formula" 2>/dev/null \
+        | grep -oE '"stable": ?"[^"]+"' | head -1 | sed -E 's/.*: ?"([^"]+)"/\1/'
+}
+
+_tool_fetch_latest() {
+    local canon=$1 os line
+    case "$canon" in
+        flutter)
+            os=$(detect_os)
+            [ "$os" = "darwin" ] && os=macos
+            _tool_curl "https://storage.googleapis.com/flutter_infra_release/releases/releases_${os}.json" | _tool_flutter_stable_from_json
+            ;;
+        node)
+            _tool_curl "https://nodejs.org/dist/index.json" | grep -m1 -E '"lts":"[A-Za-z]' | sed -E 's/.*"version":"v([^"]+)".*/\1/'
+            ;;
+        go)
+            _tool_curl 'https://go.dev/VERSION?m=text' | head -1 | sed 's/^go//'
+            ;;
+        cargo)
+            [ -x "${TOOL_DIR:-}/rustup" ] || return 0
+            line=$("$TOOL_DIR/rustup" check 2>/dev/null | grep -m1 '^stable')
+            case "$line" in
+                *"Update available"*) echo "$line" | sed -E 's/.*-> ([0-9.]+).*/\1/' ;;
+                *"Up to date"*)       echo "$line" | sed -E 's/.*: ([0-9.]+).*/\1/' ;;
+            esac
+            ;;
+        dart) ;;
+        *)
+            [ "$TOOL_MANAGER" = "brew" ] && has_cmd brew && _tool_brew_latest "$canon"
+            ;;
+    esac
+}
+
+# tool_latest <canonical tool> -> newest known version; cached 12h. With
+# XGEM_NO_NETWORK=1 only the cache is consulted.
+tool_latest() {
+    local canon=$1 f v
+    f="$XGEM_CACHE_DIR/latest-$canon"
+    if [ "$XGEM_NO_NETWORK" = "1" ]; then
+        [ -f "$f" ] && cat "$f"
+        return 0
+    fi
+    if [ -f "$f" ] && [ -n "$(find "$f" -mmin -720 2>/dev/null)" ]; then
+        cat "$f"
+        return 0
+    fi
+    v=$(_tool_fetch_latest "$canon")
+    if [ -n "$v" ]; then
+        mkdir -p "$XGEM_CACHE_DIR"
+        echo "$v" > "$f"
+        echo "$v"
+    elif [ -f "$f" ]; then
+        cat "$f"
+    fi
+}
+
+# tool_install_cmd <canonical tool> -> a shell command that installs it on
+# this platform, or empty if there's no safe automated route.
+tool_install_cmd() {
+    local canon=$1 nvm_sh="${NVM_DIR:-$HOME/.nvm}/nvm.sh"
+    case "$(detect_os)" in
+        darwin)
+            case "$canon" in
+                flutter|dart)
+                    if has_cmd fvm; then echo "fvm install stable && fvm global stable"
+                    else echo "brew install --cask flutter"; fi ;;
+                node)
+                    if [ -s "$nvm_sh" ]; then echo "bash -c 'source \"$nvm_sh\" && nvm install --lts'"
+                    else echo "brew install node"; fi ;;
+                python3) echo "brew install python" ;;
+                go)      echo "brew install go" ;;
+                docker)  echo "brew install --cask docker-desktop" ;;
+                git)     echo "brew install git" ;;
+                gh)      echo "brew install gh" ;;
+                fvm)     echo "brew install fvm" ;;
+                cargo)   echo "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y" ;;
+                swift)   echo "xcode-select --install" ;;
+            esac
+            ;;
+        linux)
+            case "$canon" in
+                cargo) echo "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y" ;;
+                fvm)   echo "curl -fsSL https://fvm.app/install.sh | bash" ;;
+                node)
+                    [ -s "$nvm_sh" ] && echo "bash -c 'source \"$nvm_sh\" && nvm install --lts'" ;;
+            esac
+            ;;
+    esac
+}
+
+# tool_ensure <tool> -> 0 once the tool is usable. Explains what's needed,
+# where to get it, and offers to install it; the caller then continues with
+# whatever was originally requested.
+tool_ensure() {
+    local tool=$1 canon recipe
+    canon=$(_tool_canon "$tool")
+    has_cmd "$tool" && return 0
+
+    log_warn "$(tool_display "$canon") is required for this but wasn't found (checked PATH, version managers like fvm/nvm, and common install locations)."
+    echo "  Download: $(tool_url "$canon")"
+
+    recipe=$(tool_install_cmd "$canon")
+    if [ -z "$recipe" ]; then
+        log_info "Install it from the link above, then re-run this command."
+        return 1
+    fi
+
+    case "$recipe" in
+        brew*)
+            if ! command -v brew >/dev/null 2>&1; then
+                log_info "That install route needs Homebrew (https://brew.sh) — install it first, or use the download link above."
+                return 1
+            fi
+            ;;
+    esac
+
+    echo "  Install command: $recipe"
+    confirm "Install $(tool_display "$canon") now?" || { log_info "Skipped. Install it from the link above when you're ready."; return 1; }
+
+    if ! bash -c "$recipe"; then
+        log_error "The install command failed (see its output above)."
+        return 1
+    fi
+
+    hash -r
+    if has_cmd "$tool"; then
+        log_success "$(tool_display "$canon") is ready."
+        return 0
+    fi
+    log_warn "Install finished but '$tool' still isn't reachable — you may need to open a new terminal or add it to PATH."
+    return 1
+}
+
+# tool_update_cmd <canonical tool> -> command that updates it given the
+# current TOOL_MANAGER, or empty when only a manual download applies.
+tool_update_cmd() {
+    local canon=$1 latest=$2 nvm_sh="${NVM_DIR:-$HOME/.nvm}/nvm.sh"
+    case "$canon" in
+        flutter)
+            case "$TOOL_MANAGER" in
+                fvm)  echo "fvm install $latest" ;;
+                brew) echo "brew upgrade --cask flutter" ;;
+                *)    echo "flutter upgrade" ;;
+            esac ;;
+        node)
+            case "$TOOL_MANAGER" in
+                nvm)  echo "bash -c 'source \"$nvm_sh\" && nvm install --lts'" ;;
+                brew) echo "brew upgrade node" ;;
+            esac ;;
+        cargo) [ "$TOOL_MANAGER" = "rustup" ] && echo "rustup update" ;;
+        *)
+            [ "$TOOL_MANAGER" = "brew" ] && case "$canon" in
+                python3) echo "brew upgrade python" ;;
+                docker)  echo "brew upgrade docker" ;;
+                *)       echo "brew upgrade $canon" ;;
+            esac ;;
+    esac
+}

package/lib/update.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+# xgem update [tool]: show which installed toolchains have newer versions
+# and apply the ones you approve.
+# Depends on lib/logger.sh, lib/utils.sh, lib/toolchain.sh.
+
+_update_one() {
+    local tool=$1 explicit=$2 version latest cmd
+
+    if ! tool_resolve "$tool"; then
+        if [ "$explicit" = "1" ]; then
+            tool_ensure "$tool"
+        fi
+        return 0
+    fi
+
+    version=$(tool_version_of "$tool")
+    latest=$(XGEM_NO_NETWORK=1 tool_latest "$tool")
+
+    if [ -z "$latest" ]; then
+        [ "$explicit" = "1" ] && log_warn "Couldn't determine the latest $(tool_display "$tool") version (offline, or no version source for a $TOOL_MANAGER install)."
+        return 0
+    fi
+    if [ -z "$version" ] || ! _tool_ver_lt "$version" "$latest"; then
+        [ "$explicit" = "1" ] && log_success "$(tool_display "$tool") ${version:-} is up to date."
+        return 0
+    fi
+
+    echo ""
+    log_info "$(tool_display "$tool"): $version -> $latest"
+    cmd=$(tool_update_cmd "$tool" "$latest")
+    if [ -z "$cmd" ]; then
+        echo "  No automated update route for this install ($TOOL_MANAGER). Download: $(tool_url "$tool")"
+        return 0
+    fi
+
+    echo "  Update command: $cmd"
+    confirm "Update $(tool_display "$tool") to $latest?" || return 0
+    if ! bash -c "$cmd"; then
+        log_error "Update failed (see output above)."
+        return 0
+    fi
+    log_success "$(tool_display "$tool") update finished."
+
+    if [ "$tool" = "flutter" ] && [ "$TOOL_MANAGER" = "fvm" ]; then
+        confirm "Make Flutter $latest your global default (fvm global)?" && fvm global "$latest"
+        if _tool_find_up .fvmrc >/dev/null || _tool_find_up .fvm/fvm_config.json >/dev/null; then
+            confirm "Also pin $latest for the project in this directory (fvm use)?" && fvm use "$latest"
+        fi
+    fi
+}
+
+cmd_update() {
+    local target=${1:-} t
+
+    if [ -n "$target" ]; then
+        tool_known "$target" || die "Unknown tool '$target'. Known: flutter node python3 go cargo docker git gh fvm swift"
+        _update_one "$(_tool_canon "$target")" 1
+        return 0
+    fi
+
+    if [ "$XGEM_NO_NETWORK" != "1" ]; then
+        log_info "Checking installed tools for updates..."
+        for t in flutter node cargo go fvm gh git docker python3; do
+            ( tool_resolve "$t" && tool_latest "$t" ) >/dev/null 2>&1 &
+        done
+        wait
+    fi
+
+    for t in flutter node cargo go fvm gh git docker python3; do
+        _update_one "$t" 0
+    done
+    echo ""
+    log_success "Update check finished. Run 'xgem doctor' for the full toolchain report."
+}

package/lib/utils.sh

@@ -24,21 +24,29 @@ is_apple_silicon() {
     [ "$(detect_os)" = "darwin" ] && [ "$(detect_arch)" = "arm64" ]
 }
 
-# has_cmd <name> -> 0/1, no output
+# has_cmd <name> -> 0/1, no output. Also finds tools that version managers
+# (fvm, nvm, ...) keep off PATH, and puts them on this process's PATH.
 has_cmd() {
-    command -v "$1" >/dev/null 2>&1
+    command -v "$1" >/dev/null 2>&1 && return 0
+    if declare -F tool_known >/dev/null 2>&1 && tool_known "$1"; then
+        tool_resolve "$1" && tool_activate
+        return $?
+    fi
+    return 1
 }
 
 # require_cmd <name> [install-hint]
 require_cmd() {
     local name=$1
     local hint=${2:-}
-    if ! has_cmd "$name"; then
-        if [ -n "$hint" ]; then
-            die "'$name' is required but not found. $hint"
-        else
-            die "'$name' is required but not found in PATH."
-        fi
+    has_cmd "$name" && return 0
+    if declare -F tool_known >/dev/null 2>&1 && tool_known "$name"; then
+        tool_ensure "$(_tool_canon "$name")" && return 0
+    fi
+    if [ -n "$hint" ]; then
+        die "'$name' is required but not found. $hint"
+    else
+        die "'$name' is required but not found in PATH."
     fi
 }
 

package/lib/version.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 # xgem version info.
 
-XGEM_VERSION="2.0.0-alpha.14"
+XGEM_VERSION="2.0.0-alpha.16"
 
 print_version() {
     echo "xgem $XGEM_VERSION"

package/lib-win/bootstrap.js

@@ -8,8 +8,13 @@ const { spawnSync } = require('node:child_process');
 const { logInfo, logSuccess, logWarn, logDebug, die } = require('./logger');
 const { hasCmd, confirm, prompt } = require('./utils');
 const scaffold = require('./scaffold');
+const toolchain = require('./toolchain');
 
 function run(cmd, args, opts = {}) {
+    if (process.env.XGEM_DRY_RUN === '1') {
+        logInfo(`(dry-run) would run: ${cmd} ${args.join(' ')}`);
+        return { status: 0 };
+    }
     return spawnSync(cmd, args, { stdio: 'inherit', shell: process.platform === 'win32', ...opts });
 }
 
@@ -42,6 +47,10 @@ async function bootstrapEnvFile() {
     if (fs.existsSync('.env')) { logDebug('.env already exists, leaving it as-is.'); return; }
     for (const example of ['.env.example', '.env.sample']) {
         if (!fs.existsSync(example)) continue;
+        if (process.env.XGEM_DRY_RUN === '1') {
+            logInfo(`(dry-run) would create .env from ${example}`);
+            return;
+        }
         fs.copyFileSync(example, '.env');
         logSuccess(`Created .env from ${example}.`);
         const missing = fs.readFileSync('.env', 'utf8')
@@ -72,6 +81,22 @@ function installWith(pm, extraArgs = []) {
     }
 }
 
+async function preflight(fw) {
+    const tool = toolchain.fwTool(fw);
+    if (tool && !(await toolchain.ensure(tool))) return false;
+    if (fw === 'flutter' && !(await toolchain.ensure('dart'))) return false;
+    if (['node', 'react', 'vue', 'angular', 'next'].includes(fw)) {
+        const pm = nodePm();
+        if (pm !== 'npm' && !hasCmd(pm)) {
+            logWarn(`This project uses ${pm} (lockfile found) but '${pm}' isn't installed.`);
+            console.log(`  Enable it via Node's bundled corepack:  corepack enable   (or: npm install -g ${pm})`);
+            if (!(await confirm(`Run 'npm install -g ${pm}' now?`))) return false;
+            run('npm', ['install', '-g', pm]);
+        }
+    }
+    return true;
+}
+
 async function bootstrapInstall(fw) {
     switch (fw) {
         case 'node':
@@ -80,36 +105,33 @@ async function bootstrapInstall(fw) {
         case 'angular':
         case 'next': {
             const pm = nodePm();
+            if (!(await confirm(`Install dependencies with ${pm}?`))) break;
             logInfo(`Installing dependencies with ${pm}...`);
             installWith(pm);
             break;
         }
         case 'flutter':
-            if (!hasCmd('flutter')) { logWarn("flutter not found — skipping 'flutter pub get'."); break; }
-            logInfo('Running flutter pub get...');
+            if (!(await confirm("Run 'flutter pub get'?"))) break;
             run('flutter', ['pub', 'get']);
             break;
         case 'python':
             if (fs.existsSync('pyproject.toml') && hasCmd('poetry')) {
-                logInfo('Installing dependencies with poetry...');
+                if (!(await confirm('Install dependencies with poetry?'))) break;
                 run('poetry', ['install']);
             } else if (fs.existsSync('requirements.txt')) {
-                if (!hasCmd('python') && !hasCmd('python3')) { logWarn('python not found — skipping install.'); break; }
                 const py = hasCmd('python') ? 'python' : 'python3';
+                if (!(await confirm('Create .venv and install requirements.txt into it?'))) break;
                 if (!fs.existsSync('.venv')) run(py, ['-m', 'venv', '.venv']);
                 const pipPath = process.platform === 'win32' ? path.join('.venv', 'Scripts', 'pip.exe') : path.join('.venv', 'bin', 'pip');
-                logInfo('Installing dependencies into .venv...');
                 run(pipPath, ['install', '-r', 'requirements.txt']);
             }
             break;
         case 'go':
-            if (!hasCmd('go')) { logWarn("go not found — skipping 'go mod download'."); break; }
-            logInfo('Running go mod download...');
+            if (!(await confirm("Run 'go mod download'?"))) break;
             run('go', ['mod', 'download']);
             break;
         case 'rust':
-            if (!hasCmd('cargo')) { logWarn("cargo not found — skipping 'cargo fetch'."); break; }
-            logInfo('Running cargo fetch...');
+            if (!(await confirm("Run 'cargo fetch'?"))) break;
             run('cargo', ['fetch']);
             break;
         case 'docker':
@@ -172,6 +194,7 @@ async function cmdBootstrap(configDir) {
         logSuccess(`Detected: ${fw}`);
     }
 
+    if (!(await preflight(fw))) die('Bootstrap stopped: a required tool is missing.');
     await bootstrapEnvFile();
     await bootstrapInstall(fw);
     await bootstrapMigrations(fw);