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

package/lib/git.sh

@@ -1,6 +1,37 @@
 #!/bin/bash
-# xgem git workflow helper: cmt / init / rm-remote / rm-branch.
-# Depends on lib/logger.sh.
+# xgem git workflow helper: cmt / init / branch / rm-remote / rm-branch /
+# pr / sync / clean-branches / hooks.
+# Depends on lib/logger.sh, lib/utils.sh.
+
+# _git_default_remote -> "origin" if configured, else the first remote,
+# else empty.
+_git_default_remote() {
+    if git remote | grep -q "^origin$"; then
+        echo origin
+    else
+        git remote | head -n 1
+    fi
+}
+
+# _git_base_branch <remote> -> the repo's default branch. Prefers gh's own
+# knowledge of it (accurate, no guessing); falls back to probing common
+# names against the remote's tracking refs when gh is unavailable/offline.
+_git_base_branch() {
+    local remote=$1
+    local base
+    if has_cmd gh; then
+        base=$(gh repo view --json defaultBranchRef --jq .defaultBranchRef.name 2>/dev/null)
+        [ -n "$base" ] && { echo "$base"; return 0; }
+    fi
+    local candidate
+    for candidate in main master develop dev; do
+        if git show-ref --verify --quiet "refs/remotes/$remote/$candidate"; then
+            echo "$candidate"
+            return 0
+        fi
+    done
+    return 1
+}
 
 cmd_git_cmt() {
     local commit_msg=$1
@@ -35,11 +66,7 @@ cmd_git_cmt() {
 
     local current_branch remote_name
     current_branch=$(git branch --show-current 2>/dev/null)
-    if git remote | grep -q "^origin$"; then
-        remote_name="origin"
-    else
-        remote_name=$(git remote | head -n 1)
-    fi
+    remote_name=$(_git_default_remote)
 
     if [ -z "$remote_name" ]; then
         log_warn "No remote configured — sync was skipped."
@@ -102,31 +129,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."
 }
 
@@ -241,14 +304,213 @@ cmd_git_branch() {
     log_success "Switched to '$selected' and set as default for this repo."
 }
 
-# xgem git <cmt|init|rm-remote|rm-branch|branch> ...
+cmd_git_pr() {
+    local current_branch remote base
+    current_branch=$(git branch --show-current 2>/dev/null)
+    [ -n "$current_branch" ] || die "Not on a branch (detached HEAD?) — nothing to open a PR from."
+    remote=$(_git_default_remote)
+    [ -n "$remote" ] || die "No remote configured."
+
+    if ! has_cmd gh || ! gh auth status >/dev/null 2>&1; then
+        has_cmd gh && log_warn "GitHub CLI (gh) is installed but not authenticated — run 'gh auth login' to enable 'xgem git pr'." \
+            || log_warn "GitHub CLI (gh) is not installed — install it for 'xgem git pr' to open PRs directly: https://cli.github.com"
+        local url owner_repo remote_url
+        remote_url=$(git remote get-url "$remote" 2>/dev/null)
+        owner_repo=$(echo "$remote_url" | sed -E 's#^git@[^:]+:##; s#^https?://[^/]+/##; s#\.git$##')
+        [ -n "$owner_repo" ] || die "Could not determine owner/repo from remote '$remote' ($remote_url)."
+        base=$(_git_base_branch "$remote")
+        url="https://github.com/$owner_repo/compare/${base:-main}...$current_branch?expand=1"
+        log_info "Open this URL to create the PR manually: $url"
+        confirm "Open it in your browser now?" && _open_url "$url"
+        return 0
+    fi
+
+    base=$(_git_base_branch "$remote") || die "Could not determine the repo's base branch."
+    [ "$current_branch" != "$base" ] || die "You're on '$base' — switch to a feature branch first."
+
+    log_info "Pushing '$current_branch' to '$remote'..."
+    git push -u "$remote" "$current_branch" || die "Push failed."
+
+    if gh pr view --json number >/dev/null 2>&1; then
+        log_success "A PR for '$current_branch' already exists."
+        confirm "Open it in your browser?" && gh pr view --web
+        return 0
+    fi
+
+    local commits commit_count title body
+    commits=$(git log --format='%s' "$remote/$base..HEAD" 2>/dev/null)
+    commit_count=$(echo "$commits" | grep -c .)
+
+    if [ "$commit_count" -le 1 ]; then
+        title=$(echo "$commits" | head -1)
+        body=""
+    else
+        # sed's \U (uppercase-first) is GNU-only — BSD sed on macOS passes
+        # it through literally instead of applying it. Capitalize via tr
+        # on just the first character instead, which is portable.
+        title=$(echo "$current_branch" | sed -E 's/[-_]/ /g')
+        title="$(echo "${title:0:1}" | tr '[:lower:]' '[:upper:]')${title:1}"
+        body=$(echo "$commits" | sed 's/^/- /')
+    fi
+
+    local title_override
+    read -r -p "PR title [$title]: " title_override
+    [ -n "$title_override" ] && title="$title_override"
+    [ -n "$title" ] || die "A PR title is required."
+
+    if gh pr create --title "$title" --body "$body" --base "$base"; then
+        log_success "PR created."
+        confirm "Open it in your browser?" && gh pr view --web
+    else
+        die "gh pr create failed."
+    fi
+}
+
+cmd_git_sync() {
+    local remote base current_branch
+    remote=$(_git_default_remote)
+    [ -n "$remote" ] || die "No remote configured."
+    base=$(_git_base_branch "$remote") || die "Could not determine the repo's base branch."
+    current_branch=$(git branch --show-current 2>/dev/null)
+
+    log_info "Fetching '$base' from '$remote'..."
+    git fetch "$remote" "$base" || die "Fetch failed."
+
+    log_info "Rebasing '$current_branch' onto '$remote/$base'..."
+    if git rebase "$remote/$base"; then
+        log_success "'$current_branch' is now up to date with '$remote/$base'."
+        return 0
+    fi
+
+    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, then 'git rebase --continue'."
+        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 .
+    else
+        log_error "Rebase failed — this looks like a connection problem, not a merge conflict (see the git error above)."
+    fi
+    exit 1
+}
+
+cmd_git_clean_branches() {
+    local remote base current_branch
+    remote=$(_git_default_remote)
+    [ -n "$remote" ] || die "No remote configured."
+
+    log_info "Pruning stale remote-tracking refs on '$remote'..."
+    git fetch "$remote" --prune || die "Fetch failed."
+
+    base=$(_git_base_branch "$remote") || die "Could not determine the repo's base branch."
+    current_branch=$(git branch --show-current 2>/dev/null)
+
+    local -a candidates=()
+    while IFS= read -r b; do
+        [ -n "$b" ] || continue
+        case "$b" in
+            "$current_branch"|main|master|develop|dev) continue ;;
+        esac
+        candidates+=("$b")
+    done < <(git branch --format='%(refname:short)' --merged "$remote/$base" 2>/dev/null)
+
+    if [ ${#candidates[@]} -eq 0 ]; then
+        log_success "No merged local branches to clean up."
+        return 0
+    fi
+
+    log_info "Local branches already merged into '$base':"
+    printf '  - %s\n' "${candidates[@]}"
+
+    confirm "Delete all ${#candidates[@]} of these local branches?" || { log_info "Cancelled."; return 0; }
+
+    local b
+    for b in "${candidates[@]}"; do
+        if git branch -d "$b" >/dev/null 2>&1; then
+            log_success "Deleted '$b'."
+        else
+            log_warn "Could not delete '$b' (not fully merged?) — left as-is."
+        fi
+    done
+}
+
+_GIT_HOOK_MARKER="# xgem-managed-hook"
+
+cmd_git_hooks_install() {
+    local git_dir hook_path
+    git_dir=$(git rev-parse --git-dir 2>/dev/null) || die "Not a git repository."
+    hook_path="$git_dir/hooks/pre-commit"
+
+    if [ -f "$hook_path" ] && ! grep -qF "$_GIT_HOOK_MARKER" "$hook_path"; then
+        log_warn "An existing pre-commit hook was found that xgem didn't create."
+        confirm "Overwrite it?" || { log_info "Cancelled."; return 0; }
+    fi
+
+    local run_tests xgem_path
+    read -r -p "Also run tests before commit (slower)? (y/N): " run_tests
+    xgem_path=$(command -v xgem)
+    [ -n "$xgem_path" ] || die "Could not resolve xgem's own path via 'command -v xgem'."
+
+    local checks_added=0
+    {
+        echo "#!/bin/bash"
+        echo "$_GIT_HOOK_MARKER"
+        local fw
+        for fw in "$CONFIG_DIR"/*/; do
+            [ -d "$fw" ] || continue
+            fw=$(basename "$fw")
+            if [ -f "$CONFIG_DIR/$fw/lint.sh" ]; then
+                echo "\"$xgem_path\" run $fw lint || exit 1"
+                checks_added=$((checks_added + 1))
+            fi
+            if [[ "$run_tests" == "y" || "$run_tests" == "Y" ]] && [ -f "$CONFIG_DIR/$fw/test.sh" ]; then
+                echo "\"$xgem_path\" run $fw test || exit 1"
+                checks_added=$((checks_added + 1))
+            fi
+        done
+    } > "$hook_path"
+    chmod +x "$hook_path"
+
+    if [ "$checks_added" -eq 0 ]; then
+        log_warn "No lint/test scripts found under $CONFIG_DIR — installed a hook that doesn't check anything yet."
+    fi
+    log_success "Installed pre-commit hook at $hook_path."
+}
+
+cmd_git_hooks_uninstall() {
+    local git_dir hook_path
+    git_dir=$(git rev-parse --git-dir 2>/dev/null) || die "Not a git repository."
+    hook_path="$git_dir/hooks/pre-commit"
+
+    [ -f "$hook_path" ] || { log_info "No pre-commit hook installed."; return 0; }
+    grep -qF "$_GIT_HOOK_MARKER" "$hook_path" || die "$hook_path wasn't created by xgem — not removing it."
+
+    rm -f "$hook_path"
+    log_success "Removed pre-commit hook."
+}
+
+cmd_git_hooks() {
+    case "$1" in
+        install)   cmd_git_hooks_install ;;
+        uninstall) cmd_git_hooks_uninstall ;;
+        *) die "Usage: xgem git hooks <install|uninstall>" ;;
+    esac
+}
+
+# xgem git <cmt|init|rm-remote|rm-branch|branch|pr|sync|clean-branches|hooks> ...
 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 ;;
-        branch)    cmd_git_branch ;;
-        *) die "Unknown git subcommand '$1'. Usage: xgem git <cmt|init|rm-remote|rm-branch|branch>" ;;
+        cmt)            cmd_git_cmt "$2" ;;
+        init)           cmd_git_init ;;
+        rm-remote)      cmd_git_rm_remote ;;
+        rm-branch)      cmd_git_rm_branch ;;
+        branch)         cmd_git_branch ;;
+        pr)             cmd_git_pr ;;
+        sync)           cmd_git_sync ;;
+        clean-branches) cmd_git_clean_branches ;;
+        hooks)          cmd_git_hooks "$2" ;;
+        *) die "Unknown git subcommand '$1'. Usage: xgem git <cmt|init|rm-remote|rm-branch|branch|pr|sync|clean-branches|hooks>" ;;
     esac
 }

package/lib/registry.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# xgem's global (cross-project) registry: which directories have been
+# scaffolded with `xgem init`/`xgem add`, so `xgem status` can find them
+# without the user having to remember or list them by hand.
+# Depends on lib/logger.sh.
+
+REGISTRY_FILE="${XGEM_REGISTRY_FILE:-$HOME/.xgem/projects}"
+
+registry_add() {
+    local path=$1
+    mkdir -p "$(dirname "$REGISTRY_FILE")"
+    touch "$REGISTRY_FILE"
+    grep -qxF "$path" "$REGISTRY_FILE" || echo "$path" >> "$REGISTRY_FILE"
+}
+
+registry_remove() {
+    local path=$1
+    [ -f "$REGISTRY_FILE" ] || return 0
+    local tmp
+    tmp=$(mktemp)
+    grep -vxF "$path" "$REGISTRY_FILE" > "$tmp" && mv "$tmp" "$REGISTRY_FILE"
+}
+
+# registry_list — prints one project path per line, pruning (and rewriting
+# the registry for) any entry that no longer exists or is no longer
+# xgem-tracked.
+registry_list() {
+    [ -f "$REGISTRY_FILE" ] || return 0
+    local -a live=()
+    local path
+    while IFS= read -r path; do
+        [ -n "$path" ] || continue
+        if [ -d "$path/$CONFIG_DIR" ]; then
+            live+=("$path")
+        fi
+    done < "$REGISTRY_FILE"
+
+    printf '%s\n' "${live[@]}"
+
+    local count
+    count=$(wc -l < "$REGISTRY_FILE" | tr -d ' ')
+    if [ "$count" != "${#live[@]}" ]; then
+        printf '%s\n' "${live[@]}" > "$REGISTRY_FILE"
+    fi
+}

package/lib/release.sh

@@ -0,0 +1,185 @@
+#!/bin/bash
+# xgem release: framework-aware version bump + changelog + tag + push.
+# Depends on lib/logger.sh, lib/utils.sh, lib/git.sh (_git_default_remote).
+
+_release_detect_version_files() {
+    local -a found=()
+    [ -f package.json ]   && found+=(package.json)
+    [ -f pubspec.yaml ]   && found+=(pubspec.yaml)
+    [ -f Cargo.toml ]     && found+=(Cargo.toml)
+    [ -f pyproject.toml ] && found+=(pyproject.toml)
+    printf '%s\n' "${found[@]}"
+}
+
+# _release_read_version <file> -> current version string (empty on failure)
+_release_read_version() {
+    case "$1" in
+        package.json)
+            grep -m1 '"version"' package.json | sed -E 's/.*"version"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/'
+            ;;
+        pubspec.yaml)
+            grep '^version:' pubspec.yaml | head -1 | awk '{print $2}'
+            ;;
+        Cargo.toml|pyproject.toml)
+            grep -m1 -E '^version[[:space:]]*=' "$1" | sed -E 's/^version[[:space:]]*=[[:space:]]*"([^"]+)".*/\1/'
+            ;;
+    esac
+}
+
+# _release_write_version <file> <new_version>
+# Uses awk (not sed's GNU-only "0,/re/" first-match addressing, which BSD
+# sed on macOS doesn't support) to replace only the first matching line.
+_release_write_version() {
+    local file=$1 new=$2 tmp
+    tmp=$(mktemp)
+    case "$file" in
+        package.json)
+            awk -v new="$new" '
+                !done && /"version"[[:space:]]*:[[:space:]]*"[^"]*"/ {
+                    sub(/"version"[[:space:]]*:[[:space:]]*"[^"]*"/, "\"version\": \"" new "\"")
+                    done = 1
+                }
+                { print }
+            ' "$file" > "$tmp" && mv "$tmp" "$file"
+            ;;
+        pubspec.yaml)
+            sed -E "s/^version:.*/version: $new/" "$file" > "$tmp" && mv "$tmp" "$file"
+            ;;
+        Cargo.toml|pyproject.toml)
+            awk -v new="$new" '
+                !done && /^version[[:space:]]*=[[:space:]]*"[^"]*"/ {
+                    sub(/^version[[:space:]]*=[[:space:]]*"[^"]*"/, "version = \"" new "\"")
+                    done = 1
+                }
+                { print }
+            ' "$file" > "$tmp" && mv "$tmp" "$file"
+            ;;
+    esac
+}
+
+# _release_bump <version> <major|minor|patch> -> new version, or empty if
+# <version> isn't a plain X.Y.Z.
+_release_bump() {
+    local version=$1 kind=$2 suffix="" core
+    core=${version%%+*}
+    [ "$core" != "$version" ] && suffix="+${version#*+}"
+
+    [[ "$core" =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)$ ]] || return 1
+    local major=${BASH_REMATCH[1]} minor=${BASH_REMATCH[2]} patch=${BASH_REMATCH[3]}
+    case "$kind" in
+        major) major=$((major + 1)); minor=0; patch=0 ;;
+        minor) minor=$((minor + 1)); patch=0 ;;
+        patch) patch=$((patch + 1)) ;;
+    esac
+    echo "${major}.${minor}.${patch}${suffix}"
+}
+
+_release_write_changelog() {
+    local version=$1 last_tag=$2
+    local -a features=() fixes=() other=()
+    local subject
+
+    while IFS= read -r subject; do
+        [ -n "$subject" ] || continue
+        case "$subject" in
+            feat*) features+=("$subject") ;;
+            fix*)  fixes+=("$subject") ;;
+            *)     other+=("$subject") ;;
+        esac
+    done < <(git log --format='%s' "${last_tag:+$last_tag..}HEAD" 2>/dev/null)
+
+    local tmp
+    tmp=$(mktemp)
+    {
+        echo "## v$version - $(date +%Y-%m-%d)"
+        if [ ${#features[@]} -gt 0 ]; then
+            echo ""
+            echo "### Features"
+            printf -- '- %s\n' "${features[@]}"
+        fi
+        if [ ${#fixes[@]} -gt 0 ]; then
+            echo ""
+            echo "### Fixes"
+            printf -- '- %s\n' "${fixes[@]}"
+        fi
+        if [ ${#other[@]} -gt 0 ]; then
+            echo ""
+            echo "### Other"
+            printf -- '- %s\n' "${other[@]}"
+        fi
+        echo ""
+        if [ -f CHANGELOG.md ]; then
+            tail -n +2 CHANGELOG.md
+        fi
+    } > "$tmp"
+    { echo "# Changelog"; echo ""; cat "$tmp"; } > CHANGELOG.md
+    rm -f "$tmp"
+}
+
+cmd_release() {
+    local -a version_files=()
+    while IFS= read -r f; do version_files+=("$f"); done < <(_release_detect_version_files)
+    [ ${#version_files[@]} -gt 0 ] || die "No recognized version file (package.json/pubspec.yaml/Cargo.toml/pyproject.toml) found here."
+
+    local file
+    if [ ${#version_files[@]} -eq 1 ]; then
+        file="${version_files[0]}"
+    else
+        echo "Multiple version files found:"
+        local i=1
+        for f in "${version_files[@]}"; do
+            echo "$i) $f"
+            i=$((i + 1))
+        done
+        local choice
+        read -r -p "Which is the canonical one to bump? [1-${#version_files[@]}]: " choice
+        [[ "$choice" =~ ^[0-9]+$ ]] && [ "$choice" -ge 1 ] && [ "$choice" -le ${#version_files[@]} ] \
+            || die "Invalid selection."
+        file="${version_files[$((choice - 1))]}"
+    fi
+
+    local current new_version bump_kind
+    current=$(_release_read_version "$file")
+    [ -n "$current" ] || die "Could not read a version from $file."
+    log_info "Current version in $file: $current"
+
+    bump_kind=$1
+    case "$bump_kind" in
+        major|minor|patch) ;;
+        "")
+            read -r -p "Bump [major/minor/patch] (default: patch): " bump_kind
+            bump_kind=${bump_kind:-patch}
+            ;;
+        *) die "Unknown bump kind '$bump_kind'. Usage: xgem release [major|minor|patch]" ;;
+    esac
+
+    new_version=$(_release_bump "$current" "$bump_kind")
+    if [ -z "$new_version" ]; then
+        log_warn "'$current' isn't a plain X.Y.Z version — can't bump it automatically."
+        read -r -p "Enter the new version directly: " new_version
+        [ -n "$new_version" ] || die "A new version is required."
+    fi
+
+    log_info "$current -> $new_version"
+    confirm "Write this version, update CHANGELOG.md, commit, and tag?" || { log_info "Cancelled."; return 0; }
+
+    _release_write_version "$file" "$new_version"
+
+    local last_tag
+    last_tag=$(git describe --tags --abbrev=0 2>/dev/null)
+    _release_write_changelog "$new_version" "$last_tag"
+
+    git add "$file" CHANGELOG.md
+    git commit -m "chore(release): v$new_version" || die "Commit failed."
+    git tag -a "v$new_version" -m "v$new_version" || die "Tag failed."
+    log_success "Committed and tagged v$new_version."
+
+    local remote current_branch
+    remote=$(_git_default_remote)
+    if [ -n "$remote" ] && confirm "Push commit and tag to '$remote'?"; then
+        current_branch=$(git branch --show-current 2>/dev/null)
+        git push "$remote" "$current_branch" && git push "$remote" "v$new_version" \
+            && log_success "Pushed v$new_version to '$remote'." \
+            || die "Push failed — the commit and tag are safe locally."
+    fi
+}

package/lib/scaffold.sh

@@ -13,12 +13,31 @@
 
 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|next) 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" ;;

package/lib/status.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# xgem status: a one-screen dashboard across every project xgem has ever
+# scaffolded, so a developer doesn't have to `cd` into each one just to see
+# what's dirty. Depends on lib/logger.sh, lib/registry.sh.
+
+# _status_row <path> — prints one tab-separated row: path, branch, dirty
+# count, ahead/behind, frameworks. Run in a subshell so `cd` never leaks.
+_status_row() {
+    local path=$1
+    (
+        cd "$path" || exit 0
+        local branch dirty ahead_behind frameworks
+        branch=$(git branch --show-current 2>/dev/null)
+        [ -n "$branch" ] || branch="-"
+        dirty=$(git status --porcelain 2>/dev/null | wc -l | tr -d ' ')
+        ahead_behind=$(git rev-list --left-right --count '@{u}...HEAD' 2>/dev/null | awk '{print "-"$1" +"$2}')
+        [ -n "$ahead_behind" ] || ahead_behind="-"
+        frameworks=$(ls "$CONFIG_DIR" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
+        [ -n "$frameworks" ] || frameworks="-"
+        printf '%s\t%s\t%s\t%s\t%s\n' "$path" "$branch" "$dirty" "$ahead_behind" "$frameworks"
+    )
+}
+
+cmd_status() {
+    local -a projects=()
+    while IFS= read -r p; do
+        [ -n "$p" ] && projects+=("$p")
+    done < <(registry_list)
+
+    if [ ${#projects[@]} -eq 0 ]; then
+        log_info "No xgem-tracked projects found yet — run 'xgem init' in a project to start tracking it."
+        return 0
+    fi
+
+    printf '%-45s %-20s %-6s %-10s %s\n' "PROJECT" "BRANCH" "DIRTY" "AHEAD/BEHIND" "FRAMEWORKS"
+    local p row
+    for p in "${projects[@]}"; do
+        row=$(_status_row "$p")
+        IFS=$'\t' read -r path branch dirty ahead_behind frameworks <<< "$row"
+        printf '%-45s %-20s %-6s %-10s %s\n' "$path" "$branch" "$dirty" "$ahead_behind" "$frameworks"
+    done
+}

package/lib/utils.sh

@@ -42,6 +42,17 @@ require_cmd() {
     fi
 }
 
+# _open_url <url> — best-effort browser open, silent no-op on an OS xgem
+# doesn't know how to open a browser on.
+_open_url() {
+    local url=$1
+    case "$(detect_os)" in
+        darwin) open "$url" 2>/dev/null ;;
+        linux)  xdg-open "$url" 2>/dev/null ;;
+        *) log_debug "Don't know how to open a browser on this OS — visit $url manually." ;;
+    esac
+}
+
 # confirm "prompt text" -> 0 if approved, 1 otherwise
 # Honors XGEM_YES=1 (from --yes) to auto-approve, and always returns 1
 # (declines) under XGEM_DRY_RUN so callers never apply changes in dry-run mode.