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

package/lib/git.sh

@@ -1,6 +1,66 @@
 #!/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
+}
+
+_git_resolve_conflicts_help() {
+    local files
+    files=$(git diff --name-only --diff-filter=U 2>/dev/null)
+    if [ -n "$files" ]; then
+        log_warn "Files with conflicts:"
+        echo "$files" | sed 's/^/  - /'
+    fi
+    log_warn "Resolve them, then run: git add <files> && git rebase --continue   (or give up with: git rebase --abort)"
+
+    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" ]] || return 0
+
+    if has_cmd code; then
+        code .
+        return 0
+    fi
+    if [ "$(detect_os)" = "darwin" ]; then
+        local app
+        for app in "Visual Studio Code" "Visual Studio Code - Insiders"; do
+            if [ -d "/Applications/$app.app" ]; then
+                open -a "$app" .
+                return 0
+            fi
+        done
+    fi
+    log_warn "VS Code's 'code' command isn't on your PATH (a shell alias doesn't count — scripts can't see it). In VS Code run Cmd+Shift+P -> 'Shell Command: Install code command in PATH', or open the files above manually."
+}
 
 cmd_git_cmt() {
     local commit_msg=$1
@@ -35,11 +95,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."
@@ -88,9 +144,7 @@ cmd_git_cmt() {
             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 .
+        _git_resolve_conflicts_help
         exit 1
     fi
 
@@ -277,14 +331,210 @@ 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!"
+        _git_resolve_conflicts_help
+    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/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.

package/lib/version.sh

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