xgem-cli 2.0.0-alpha.1 → 2.0.0-alpha.12

package/lib/git.sh

@@ -24,9 +24,13 @@ cmd_git_cmt() {
         die "Invalid choice. Operation aborted."
     fi
 
-    log_info "Committing changes..."
-    if ! git commit -m "$commit_msg"; then
-        die "Commit failed. Aborting before pull/push."
+    if git diff --cached --quiet; then
+        log_warn "Nothing staged to commit — checking whether there's anything already committed to sync."
+    else
+        log_info "Committing changes..."
+        if ! git commit -m "$commit_msg"; then
+            die "Commit failed. Aborting before pull/push."
+        fi
     fi
 
     local current_branch remote_name
@@ -38,14 +42,52 @@ cmd_git_cmt() {
     fi
 
     if [ -z "$remote_name" ]; then
-        log_warn "Local commit dropped cleanly, but no remote is configured — sync was skipped."
+        log_warn "No remote configured — sync was skipped."
+        return 0
+    fi
+
+    # A pull needs something to pull FROM. If this branch has never been
+    # pushed before, there's no remote ref to pull, and `git pull --rebase`
+    # fails with "couldn't find remote ref <branch>" — which is not a
+    # connection problem or a conflict, just a brand-new branch. Check for
+    # that specific case first so it gets its own accurate message instead
+    # of being lumped in with real connectivity failures.
+    git ls-remote --exit-code --heads "$remote_name" "$current_branch" >/dev/null 2>&1
+    local ls_remote_status=$?
+
+    if [ "$ls_remote_status" -eq 2 ]; then
+        log_info "'$current_branch' doesn't exist on '$remote_name' yet — pushing to create it..."
+        if git push -u "$remote_name" "$current_branch"; then
+            log_success "Git workflow complete! Branch created and pushed."
+        else
+            die "Push operation failed."
+        fi
+        return 0
+    elif [ "$ls_remote_status" -ne 0 ]; then
+        log_error "Could not reach '$remote_name' to check for '$current_branch' — this looks like a real connection problem."
+        log_warn "Your commit is safe locally. Re-run 'xgem git cmt' once connectivity is restored, or push manually: git push $remote_name $current_branch"
+        exit 1
+    fi
+
+    local ahead_count
+    ahead_count=$(git rev-list --count "$remote_name/$current_branch..$current_branch" 2>/dev/null)
+    if [ "$ahead_count" = "0" ]; then
+        log_success "Already up to date with '$remote_name/$current_branch' — nothing to push."
         return 0
     fi
 
     log_info "Pulling updates from remote '$remote_name' on '$current_branch' via rebase..."
     if ! git pull --rebase "$remote_name" "$current_branch"; then
-        log_error "MERGE CONFLICT DETECTED!"
-        log_warn "Execution paused. Resolve conflicts to proceed."
+        local git_dir
+        git_dir=$(git rev-parse --git-dir 2>/dev/null)
+        if [ -d "$git_dir/rebase-merge" ] || [ -d "$git_dir/rebase-apply" ]; then
+            log_error "MERGE CONFLICT DETECTED!"
+            log_warn "Execution paused. Resolve conflicts to proceed."
+        else
+            log_error "Could not sync with '$remote_name' — this looks like a connection problem, not a merge conflict (see the git error above)."
+            log_warn "Your commit is safe locally. Re-run 'xgem git cmt' once connectivity is restored, or push manually: git push $remote_name $current_branch"
+            exit 1
+        fi
         local open_editor
         read -r -p "Do you want to open VS Code to resolve this now? (y/n): " open_editor
         [[ "$open_editor" == "y" || "$open_editor" == "Y" ]] && code .
@@ -60,31 +102,67 @@ cmd_git_cmt() {
     fi
 }
 
-cmd_git_init() {
-    log_info "Initializing local Git repository..."
-    git init
+_cmd_git_init_manual_remote() {
+    local remote_name=$1
+    local remote_url user_remote_name
+    read -r -p "Enter remote repository URL (or leave blank to skip): " remote_url
+    [ -n "$remote_url" ] || return 0
 
-    local remote_name="origin" remote_url user_remote_name branch_name
-    read -r -p "Enter remote repository URL: " remote_url
-    if [ -n "$remote_url" ]; then
-        read -r -p "Enter remote name (default: origin): " user_remote_name
-        [ -n "$user_remote_name" ] && remote_name="$user_remote_name"
+    read -r -p "Enter remote name (default: $remote_name): " user_remote_name
+    [ -n "$user_remote_name" ] && remote_name="$user_remote_name"
 
-        if git remote | grep -q "^$remote_name$"; then
-            git remote set-url "$remote_name" "$remote_url"
-            log_success "Remote '$remote_name' already existed. URL updated."
-        else
-            git remote add "$remote_name" "$remote_url"
-            log_success "Remote '$remote_name' successfully added."
-        fi
+    if git remote | grep -q "^$remote_name$"; then
+        git remote set-url "$remote_name" "$remote_url"
+        log_success "Remote '$remote_name' already existed. URL updated."
+    else
+        git remote add "$remote_name" "$remote_url"
+        log_success "Remote '$remote_name' successfully added."
     fi
+}
 
+cmd_git_init() {
+    log_info "Initializing local Git repository..."
+    git init
+
+    local branch_name
     read -r -p "Enter branch name (default: main): " branch_name
     branch_name=${branch_name:-main}
     git branch -M "$branch_name"
 
     git add .
     git commit -m "initial changes" 2>/dev/null
+
+    # Real GitHub repo creation, not just wiring a remote to a URL you
+    # already had to go create by hand — this is the whole point of
+    # `xgem git init` over plain `git init`. Falls back to the manual-URL
+    # flow if `gh` isn't installed/authenticated.
+    if has_cmd gh && gh auth status >/dev/null 2>&1; then
+        local create_choice
+        read -r -p "Create a new GitHub repository for this project right now? (Y/n): " create_choice
+        create_choice=${create_choice:-y}
+        if [[ "$create_choice" == "y" || "$create_choice" == "Y" ]]; then
+            local repo_name visibility vis_flag
+            read -r -p "Repository name (default: $(basename "$PWD")): " repo_name
+            repo_name=${repo_name:-$(basename "$PWD")}
+            read -r -p "Public or private? [public/private] (default: private): " visibility
+            visibility=${visibility:-private}
+            vis_flag="--private"
+            [[ "$visibility" == pub* || "$visibility" == Pub* ]] && vis_flag="--public"
+
+            if gh repo create "$repo_name" "$vis_flag" --source=. --remote=origin --push; then
+                log_success "Created GitHub repo '$repo_name' and pushed '$branch_name' to it."
+            else
+                log_error "gh repo create failed — falling back to manual remote setup."
+                _cmd_git_init_manual_remote origin
+            fi
+            log_success "Local baseline configuration setup completed."
+            return 0
+        fi
+    elif has_cmd gh; then
+        log_warn "GitHub CLI (gh) is installed but not authenticated — run 'gh auth login' to enable one-step repo creation next time."
+    fi
+
+    _cmd_git_init_manual_remote origin
     log_success "Local baseline configuration setup completed."
 }
 
@@ -144,13 +222,69 @@ cmd_git_rm_branch() {
     fi
 }
 
-# xgem git <cmt|init|rm-remote|rm-branch> ...
+# cmd_git_branch: lists local branches, lets the user pick one (or create a
+# new one), checks it out, and remembers it as this repo's default so
+# there's a quick way back to it later. `xgem git cmt` always operates on
+# whatever's actually checked out (that's the only thing that's correct for
+# a commit), so this command's job is the checkout + remembering, not
+# changing how cmt picks its branch.
+cmd_git_branch() {
+    local -a branches=()
+    while IFS= read -r line; do
+        [ -n "$line" ] && branches+=("$line")
+    done < <(git branch --format='%(refname:short)' 2>/dev/null)
+
+    [ ${#branches[@]} -gt 0 ] || die "No local branches found."
+
+    local current_branch
+    current_branch=$(git branch --show-current 2>/dev/null)
+
+    echo "Available branches:"
+    local i=1 b
+    for b in "${branches[@]}"; do
+        if [ "$b" = "$current_branch" ]; then
+            echo "$i) $b (current)"
+        else
+            echo "$i) $b"
+        fi
+        i=$((i + 1))
+    done
+    local create_option=$i
+    echo "$create_option) Create new branch"
+
+    local choice
+    read -r -p "Select [1-$create_option]: " choice
+
+    if [ "$choice" = "$create_option" ]; then
+        local new_branch
+        read -r -p "Enter new branch name: " new_branch
+        [ -n "$new_branch" ] || die "Branch name cannot be empty."
+        git checkout -b "$new_branch" || die "Could not create branch '$new_branch'."
+        git config --local xgem.default-branch "$new_branch"
+        log_success "Created and switched to '$new_branch', set as default for this repo."
+        return 0
+    fi
+
+    if ! [[ "$choice" =~ ^[0-9]+$ ]] || [ "$choice" -lt 1 ] || [ "$choice" -gt ${#branches[@]} ]; then
+        die "Invalid selection."
+    fi
+
+    local selected="${branches[$((choice - 1))]}"
+    if [ "$selected" != "$current_branch" ]; then
+        git checkout "$selected" || die "Could not switch to branch '$selected'."
+    fi
+    git config --local xgem.default-branch "$selected"
+    log_success "Switched to '$selected' and set as default for this repo."
+}
+
+# xgem git <cmt|init|rm-remote|rm-branch|branch> ...
 cmd_git() {
     case "$1" in
         cmt)       cmd_git_cmt "$2" ;;
         init)      cmd_git_init ;;
         rm-remote) cmd_git_rm_remote ;;
         rm-branch) cmd_git_rm_branch ;;
-        *) die "Unknown git subcommand '$1'. Usage: xgem git <cmt|init|rm-remote|rm-branch>" ;;
+        branch)    cmd_git_branch ;;
+        *) die "Unknown git subcommand '$1'. Usage: xgem git <cmt|init|rm-remote|rm-branch|branch>" ;;
     esac
 }

package/lib/ios.sh

@@ -60,8 +60,13 @@ ios_deployment_target_for_config() {
 
     if has_cmd xcodebuild; then
         local value
+        # Anchored: newer Xcode also emits DEPLOYMENT_TARGET_SETTING_NAME =
+        # IPHONEOS_DEPLOYMENT_TARGET (a meta-setting whose *value* is that
+        # string), which an unanchored grep matches before the real
+        # "IPHONEOS_DEPLOYMENT_TARGET = 15.6" line — anchoring to the key
+        # position avoids grabbing that decoy.
         value=$(xcodebuild -showBuildSettings "${xcb_args[@]}" -configuration "$config" 2>/dev/null \
-            | grep -m1 'IPHONEOS_DEPLOYMENT_TARGET' | awk '{print $NF}')
+            | grep -m1 -E '^[[:space:]]*IPHONEOS_DEPLOYMENT_TARGET[[:space:]]*=' | awk '{print $NF}')
         [ -n "$value" ] && { echo "$value"; return 0; }
     fi
 
@@ -80,15 +85,36 @@ ios_pbxproj_current_max_target() {
 }
 
 # ios_required_spm_deployment_target [project_dir]
-# Reads .dart_tool/package_config.json (written by `flutter pub get`) to
-# find every resolved package's own ios/Package.swift, and returns the
-# highest .iOS(.vNN) platform floor declared across them. This replaces
-# hardcoding a guessed value (e.g. "15.0") with an actual measurement of
-# what the resolved dependency graph requires.
+# Returns the highest .iOS(.vNN) platform floor declared across every
+# resolved SwiftPM plugin, instead of hardcoding a guessed value.
+#
+# Primary source: ios/Flutter/ephemeral/Packages/.packages/<name>-<version>/,
+# which `flutter pub get` itself populates with each SPM-enabled plugin as
+# part of dependency resolution — this is the actual, already-resolved
+# location Xcode/SPM uses, not a path we have to reconstruct. Scanning it
+# directly sidesteps having to guess each plugin's on-disk manifest layout
+# (which varies — not every plugin puts Package.swift at <root>/ios/).
+#
+# Falls back to parsing .dart_tool/package_config.json's rootUri entries
+# (assuming the common <root>/ios/Package.swift convention) only if that
+# ephemeral directory doesn't exist yet — e.g. before any pub get has run.
 ios_required_spm_deployment_target() {
     local project_dir=${1:-.}
-    local pkg_config="$project_dir/.dart_tool/package_config.json"
+    local packages_dir="$project_dir/ios/Flutter/ephemeral/Packages/.packages"
+
+    if [ -d "$packages_dir" ]; then
+        # -L: per-plugin dirs here are frequently symlinks into pub-cache;
+        # without -L, find silently skips descending into them.
+        find -L "$packages_dir" -maxdepth 4 -name "Package.swift" -print0 2>/dev/null \
+            | xargs -0 grep -ohE '\.iOS\(\.v[0-9_]+\)|\.iOS\("[0-9.]+"\)' 2>/dev/null \
+            | grep -oE '[0-9]+(\.[0-9]+)?(_[0-9]+)?' | tr '_' '.' \
+            | sort -g | tail -1
+        return 0
+    fi
+
+    log_debug "No resolved SwiftPM packages directory at $packages_dir yet; falling back to package_config.json."
 
+    local pkg_config="$project_dir/.dart_tool/package_config.json"
     [ -f "$pkg_config" ] || { log_debug "No .dart_tool/package_config.json — run flutter pub get first."; return 1; }
     has_cmd python3 || { log_debug "python3 not found; cannot parse package_config.json."; return 1; }
 
@@ -118,9 +144,12 @@ for pkg in data.get("packages", []):
     except OSError:
         continue
 
-    for m in re.finditer(r"\.iOS\(\.v(\d+(?:_\d+)?)\)", content):
+    # Both SPM syntaxes: enum .iOS(.v15) and string .iOS("15.0") (the form
+    # Flutter's own generator uses).
+    for m in re.finditer(r'\.iOS\(\.v(\d+(?:_\d+)?)\)|\.iOS\("(\d+(?:\.\d+)?)"\)', content):
+        raw = m.group(1) or m.group(2)
         try:
-            fv = float(m.group(1).replace("_", "."))
+            fv = float(raw.replace("_", "."))
         except ValueError:
             continue
         max_target = max(max_target, fv)
@@ -164,21 +193,40 @@ ios_generated_package_swift_path() {
         echo "$guess"
         return 0
     fi
-    find "$project_dir/ios" -maxdepth 6 -type f -name "Package.swift" \
+    # -L: plugin package directories under ephemeral/Packages/.packages are
+    # frequently symlinks into the pub-cache; a plain find silently skips
+    # symlinked directories instead of descending into them.
+    find -L "$project_dir/ios" -maxdepth 6 -type f -name "Package.swift" \
         -path "*FlutterGeneratedPluginSwiftPackage*" 2>/dev/null | head -1
 }
 
+# SPM's SupportedPlatform.iOS accepts two syntaxes: the enum form .iOS(.v15)
+# for the fixed known-version cases, and a string form .iOS("15.0") for
+# arbitrary versions — Flutter's own code generator uses the *string* form
+# for FlutterGeneratedPluginSwiftPackage, not the enum form. Matching only
+# the enum form (as an earlier version of this function did) means the
+# patch step silently never matches anything on a real generated package:
+# sed finds no match, writes back an identical file, and "succeeds" while
+# doing nothing.
+_ios_extract_platform_version() {
+    grep -oE '\.iOS\(\.v[0-9_]+\)|\.iOS\("[0-9.]+"\)' | head -1 \
+        | grep -oE '[0-9]+(\.[0-9]+)?(_[0-9]+)?' | tr '_' '.'
+}
+
 ios_generated_package_target() {
     local project_dir=${1:-.}
     local pkg
     pkg=$(ios_generated_package_swift_path "$project_dir")
     [ -n "$pkg" ] && [ -f "$pkg" ] || return 1
-    grep -oE '\.iOS\(\.v[0-9_]+\)' "$pkg" | head -1 | grep -oE '[0-9_]+' | tr '_' '.'
+    _ios_extract_platform_version < "$pkg"
 }
 
 # Last-resort workaround for the still-open upstream desync bug: directly
 # patch the generated package's platform declaration. Always logged loudly
 # — this is a documented workaround for a known bug, never a silent hack.
+# Writes the string form (.iOS("15.0")) since that's what Flutter's own
+# generator uses in this file — matching its existing convention rather
+# than introducing a different syntax.
 ios_patch_generated_package_target() {
     local new_target=$1
     local project_dir=${2:-.}
@@ -190,10 +238,9 @@ ios_patch_generated_package_target() {
     fi
 
     log_warn "Working around known Flutter SPM bug (flutter/flutter#186804): the regenerated package still doesn't match your deployment target, so patching it directly."
-    local token=${new_target//./_}
     local tmp
     tmp=$(mktemp)
-    sed -E "s/\.iOS\(\.v[0-9_]+\)/.iOS(.v${token})/g" "$pkg" > "$tmp"
+    sed -E "s/\.iOS\(\.v[0-9_]+\)/.iOS(\"${new_target}\")/g; s/\.iOS\(\"[0-9.]+\"\)/.iOS(\"${new_target}\")/g" "$pkg" > "$tmp"
     mv "$tmp" "$pkg"
     log_success "Patched generated package platform to iOS $new_target."
 }
@@ -205,14 +252,39 @@ ios_regenerate_generated_package() {
     ( cd "$project_dir" && flutter pub get )
 }
 
+# ios_parse_required_from_build_log <log_file>
+# Statically scanning plugin manifests to predict the required deployment
+# target has proven unreliable in practice (plugin authors structure SPM
+# manifests differently, package dirs can be symlinks, etc.). Xcode itself
+# always computes this correctly and states it plainly in its own error:
+# "requires minimum platform version X for the iOS platform". Parsing that
+# directly is the authoritative fallback when the static pre-check misses
+# something.
+ios_parse_required_from_build_log() {
+    local log_file=$1
+    grep -oE "requires minimum platform version [0-9]+(\.[0-9]+)?" "$log_file" 2>/dev/null \
+        | grep -oE '[0-9]+(\.[0-9]+)?' \
+        | sort -g | tail -1
+}
+
 ios_known_issue_check() {
-    log_warn "Known upstream issue (flutter/flutter#186804, #189422, #162072): FlutterGeneratedPluginSwiftPackage's deployment target can desync from your app's IPHONEOS_DEPLOYMENT_TARGET. Currently open — xgem detects and works around it automatically below."
+    log_warn "Known upstream issue (flutter/flutter#186804, #189422, #162072): FlutterGeneratedPluginSwiftPackage's deployment target can desync from your app's IPHONEOS_DEPLOYMENT_TARGET — independently, even when the app's own target is already high enough. Currently open — xgem detects and works around it automatically below."
+}
+
+# _ios_ver_lt a b -> true if a < b, numeric comparison (not string equality,
+# since "15" and "15.0" are the same version but different strings).
+_ios_ver_lt() {
+    awk -v a="$1" -v b="$2" 'BEGIN{exit !(a<b)}'
 }
 
 # ios_reconcile_deployment_target [project_dir]
-# The core "self-healing" step: detect a required-vs-current mismatch, plan
-# the fix, confirm (unless --yes/--dry-run), apply, regenerate, verify, and
-# fall back to the documented workaround if the upstream bug is still biting.
+# The core "self-healing" step. Checks TWO independent things against the
+# required version — the app's own pbxproj target, AND
+# FlutterGeneratedPluginSwiftPackage's own declared platform — because the
+# upstream bug is exactly that these two can desync from each other. A
+# project whose pbxproj is already at (say) 15.6 can still have a generated
+# package stuck at 13.0; checking only the pbxproj target (as an earlier
+# version of this function did) misses that case entirely.
 # Returns 0 if no action was needed or the fix succeeded; 1 if it couldn't
 # reconcile and the caller should stop before attempting a build.
 ios_reconcile_deployment_target() {
@@ -220,46 +292,53 @@ ios_reconcile_deployment_target() {
 
     ios_project_uses_spm "$project_dir" || { log_debug "Project does not use SwiftPM; skipping deployment-target reconciliation."; return 0; }
 
-    local required current
+    local required
     required=$(ios_required_spm_deployment_target "$project_dir")
-    current=$(ios_deployment_target_for_config "Release" "$project_dir")
-
     if [ -z "$required" ]; then
         log_debug "Could not determine a required deployment target from resolved SPM plugins; skipping reconciliation."
         return 0
     fi
-    if [ -z "$current" ]; then
-        log_warn "Could not determine the project's current deployment target; proceeding without reconciliation."
+
+    ios_known_issue_check
+
+    local current generated
+    current=$(ios_deployment_target_for_config "Release" "$project_dir")
+    generated=$(ios_generated_package_target "$project_dir")
+
+    local pbxproj_needs_bump=0 generated_needs_fix=0
+    [ -n "$current" ] && _ios_ver_lt "$current" "$required" && pbxproj_needs_bump=1
+    if [ -z "$generated" ] || _ios_ver_lt "$generated" "$required"; then
+        generated_needs_fix=1
+    fi
+
+    if [ "$pbxproj_needs_bump" = 0 ] && [ "$generated_needs_fix" = 0 ]; then
+        log_debug "Deployment target ($current) and generated package ($generated) already satisfy SwiftPM requirement ($required)."
         return 0
     fi
 
-    ios_known_issue_check
+    log_warn "Resolved SwiftPM plugins require iOS $required."
+    [ "$pbxproj_needs_bump" = 1 ] && echo "  - project.pbxproj currently targets iOS $current"
+    [ "$generated_needs_fix" = 1 ] && echo "  - FlutterGeneratedPluginSwiftPackage currently declares iOS ${generated:-unknown}"
+    echo "Plan:"
+    [ "$pbxproj_needs_bump" = 1 ] && echo "  1. Set IPHONEOS_DEPLOYMENT_TARGET = $required across every build configuration in project.pbxproj"
+    echo "  2. Clear ios/Flutter/ephemeral and re-run 'flutter pub get' to regenerate FlutterGeneratedPluginSwiftPackage"
+    echo "  3. Verify the regenerated package declares iOS $required; if it still doesn't (known upstream bug), patch it directly"
+
+    if ! confirm "Apply this fix?"; then
+        log_warn "Skipped. The build will likely fail SwiftPM resolution until this is reconciled manually."
+        return 1
+    fi
+
+    [ "$pbxproj_needs_bump" = 1 ] && ios_pbxproj_patch_deployment_target "$required" "$project_dir"
+    ios_regenerate_generated_package "$project_dir"
 
-    if awk -v a="$required" -v b="$current" 'BEGIN{exit !(a>b)}'; then
-        log_warn "Resolved SwiftPM plugins require iOS $required, but the project targets iOS $current."
-        echo "Plan:"
-        echo "  1. Set IPHONEOS_DEPLOYMENT_TARGET = $required across every build configuration in project.pbxproj"
-        echo "  2. Clear ios/Flutter/ephemeral and re-run 'flutter pub get' to regenerate FlutterGeneratedPluginSwiftPackage"
-        echo "  3. Verify the regenerated package declares iOS $required; if it still doesn't (known upstream bug), patch it directly"
-
-        if ! confirm "Apply this fix?"; then
-            log_warn "Skipped. The build will likely fail SwiftPM resolution until the deployment target is reconciled manually."
-            return 1
-        fi
-
-        ios_pbxproj_patch_deployment_target "$required" "$project_dir"
-        ios_regenerate_generated_package "$project_dir"
-
-        local regenerated
-        regenerated=$(ios_generated_package_target "$project_dir")
-        if [ "$regenerated" = "$required" ]; then
-            log_success "Generated package now correctly declares iOS $regenerated."
-        else
-            log_warn "Generated package declares '${regenerated:-unknown}' after regeneration, not $required."
-            ios_patch_generated_package_target "$required" "$project_dir"
-        fi
+    local regenerated
+    regenerated=$(ios_generated_package_target "$project_dir")
+    if [ -n "$regenerated" ] && ! _ios_ver_lt "$regenerated" "$required"; then
+        log_success "Generated package now correctly declares iOS $regenerated."
     else
-        log_debug "Deployment target ($current) already satisfies SwiftPM requirement ($required)."
+        log_warn "Generated package declares '${regenerated:-unknown}' after regeneration, still below $required."
+        ios_patch_generated_package_target "$required" "$project_dir"
     fi
 
     return 0

package/lib/scaffold.sh

@@ -11,14 +11,33 @@
 #
 # Depends on lib/logger.sh and XGEM_HOME (set by bin/xgem).
 
-ALL_FRAMEWORKS=(flutter node python react vue angular go rust docker swift)
+ALL_FRAMEWORKS=(flutter node python react vue angular next go rust docker swift)
+
+# _package_json_has_script <script> — checks the CURRENT directory's
+# package.json, not a guess. Used to only offer lint/test automation when
+# the project actually has those scripts, instead of always generating
+# scripts that fail with "Missing script" on projects that don't.
+_package_json_has_script() {
+    [ -f package.json ] || return 1
+    grep -qE "\"$1\"[[:space:]]*:" package.json 2>/dev/null
+}
 
 framework_scripts() {
     case "$1" in
         flutter) echo "hard-clean build build-runner" ;;
-        node)    echo "hard-clean build start" ;;
+        node)
+            local scripts="hard-clean build start"
+            _package_json_has_script lint && scripts="$scripts lint"
+            _package_json_has_script test && scripts="$scripts test"
+            echo "$scripts"
+            ;;
         python)  echo "hard-clean install" ;;
-        react|vue|angular) echo "hard-clean build dev" ;;
+        react|vue|angular|next)
+            local scripts="hard-clean build dev"
+            _package_json_has_script lint && scripts="$scripts lint"
+            _package_json_has_script test && scripts="$scripts test"
+            echo "$scripts"
+            ;;
         go)      echo "hard-clean build" ;;
         rust)    echo "hard-clean build" ;;
         docker)  echo "hard-clean build-up" ;;
@@ -30,8 +49,8 @@ framework_scripts() {
 _scaffold_template_dir() {
     local framework=$1
     case "$framework" in
-        react|vue|angular) echo "$XGEM_HOME/templates/webframework" ;;
-        *)                 echo "$XGEM_HOME/templates/$framework" ;;
+        react|vue|angular|next) echo "$XGEM_HOME/templates/webframework" ;;
+        *)                      echo "$XGEM_HOME/templates/$framework" ;;
     esac
 }
 

package/lib/version.sh

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

package/lib-win/doctor.js

@@ -0,0 +1,44 @@
+// xgem Windows engine doctor — mirrors lib/doctor.sh's general report.
+// No iOS/SwiftPM engine exists here (see flutter.js) since Xcode has no
+// Windows equivalent; `doctor ios` explains that instead of pretending.
+
+const { getVersion, detectArch } = require('./utils');
+const { paint } = require('./logger');
+
+function printGeneral() {
+    console.log(paint('cyan', '=== xgem doctor (Windows) ==='));
+    console.log(`OS:              win32`);
+    console.log(`Arch:            ${detectArch()}`);
+    console.log(`git:             ${getVersion('git') || 'not found'}`);
+    console.log(`flutter:         ${getVersion('flutter') || 'not found'}`);
+    console.log(`dart:            ${getVersion('dart') || 'not found'}`);
+    console.log(`node:            ${getVersion('node') || 'not found'}`);
+    console.log(`python:          ${getVersion('python') || getVersion('python3') || 'not found'}`);
+    console.log(`go:              ${getVersion('go', ['version']) || 'not found'}`);
+    console.log(`cargo:           ${getVersion('cargo') || 'not found'}`);
+    console.log(`docker:          ${getVersion('docker') || 'not found'}`);
+}
+
+function printIos() {
+    console.log(paint('cyan', '=== xgem doctor ios (Windows) ==='));
+    console.log(paint('yellow', 'iOS/macOS builds are not available on Windows — Xcode has no Windows equivalent.'));
+    console.log('Use WSL2 with a Mac, or a real Mac, for Flutter iOS builds.');
+    const flutterVersion = getVersion('flutter');
+    if (flutterVersion) {
+        console.log(`\nflutter is installed here (${flutterVersion}) and can still build Android/Windows targets:`);
+        console.log('  xgem run flutter build   (choose APK or Windows)');
+    }
+}
+
+function cmdDoctor(target) {
+    if (target === 'ios') {
+        printIos();
+    } else if (!target) {
+        printGeneral();
+    } else {
+        const { die } = require('./logger');
+        die(`Unknown doctor target '${target}'. Usage: xgem doctor [ios]`);
+    }
+}
+
+module.exports = { cmdDoctor, printGeneral, printIos };