@revotools/cli 0.4.0 → 0.6.0

package/dist/revo

@@ -8,7 +8,7 @@ set -euo pipefail
 # Exit cleanly on SIGPIPE (e.g., revo clone | grep, revo status | head)
 trap 'exit 0' PIPE
 
-REVO_VERSION="0.4.0"
+REVO_VERSION="0.6.0"
 
 
 # === lib/ui.sh ===
@@ -736,6 +736,12 @@ yaml_add_repo() {
 REVO_WORKSPACE_ROOT=""
 REVO_CONFIG_FILE=""
 REVO_REPOS_DIR=""
+# When invoked from inside .revo/workspaces/<name>/, REVO_REPOS_DIR is
+# overridden to point at that workspace dir so existing commands (status,
+# commit, push, pr, exec, ...) operate on the workspace's copies of the
+# repos rather than the source tree under repos/. REVO_ACTIVE_WORKSPACE
+# holds the workspace name in that case (empty otherwise).
+REVO_ACTIVE_WORKSPACE=""
 
 # Find workspace root by searching upward for revo.yaml (or mars.yaml as fallback)
 # Usage: config_find_root [start_dir]
@@ -749,6 +755,7 @@ config_find_root() {
             REVO_WORKSPACE_ROOT="$current"
             REVO_CONFIG_FILE="$current/revo.yaml"
             REVO_REPOS_DIR="$current/repos"
+            _config_apply_workspace_override "$start_dir"
             return 0
         fi
         # Fallback: support mars.yaml for migration from Mars
@@ -756,6 +763,7 @@ config_find_root() {
             REVO_WORKSPACE_ROOT="$current"
             REVO_CONFIG_FILE="$current/mars.yaml"
             REVO_REPOS_DIR="$current/repos"
+            _config_apply_workspace_override "$start_dir"
             return 0
         fi
         current="$(dirname "$current")"
@@ -764,6 +772,37 @@ config_find_root() {
     return 1
 }
 
+# If start_dir is inside .revo/workspaces/<name>/, point REVO_REPOS_DIR at
+# that workspace and remember the active workspace name. Otherwise leave
+# things alone. Called from config_find_root after the root has been set.
+_config_apply_workspace_override() {
+    local start_dir="$1"
+    REVO_ACTIVE_WORKSPACE=""
+
+    [[ -z "$REVO_WORKSPACE_ROOT" ]] && return 0
+
+    local prefix="$REVO_WORKSPACE_ROOT/.revo/workspaces/"
+    case "$start_dir/" in
+        "$prefix"*)
+            local rest="${start_dir#"$prefix"}"
+            local ws_name="${rest%%/*}"
+            if [[ -n "$ws_name" ]] && [[ -d "$prefix$ws_name" ]]; then
+                REVO_REPOS_DIR="$prefix$ws_name"
+                REVO_ACTIVE_WORKSPACE="$ws_name"
+            fi
+            ;;
+    esac
+    return 0
+}
+
+# Always returns the source repos dir ($REVO_WORKSPACE_ROOT/repos),
+# regardless of any active workspace override. Used by `revo workspace`
+# itself, which must read from the source tree even when invoked from
+# inside another workspace.
+config_source_repos_dir() {
+    printf '%s/repos' "$REVO_WORKSPACE_ROOT"
+}
+
 # Initialize workspace in current directory
 # Usage: config_init "workspace_name"
 # Returns: 0 on success, 1 if already initialized
@@ -2941,6 +2980,35 @@ _context_write_file() {
         printf '\n> Warning: a dependency cycle was detected. Listed in best-effort order.\n' >> "$output"
     fi
 
+    # Active workspaces (any .revo/workspaces/*/ dirs)
+    local workspaces_dir="$REVO_WORKSPACE_ROOT/.revo/workspaces"
+    if [[ -d "$workspaces_dir" ]]; then
+        local has_workspaces=0
+        local ws
+        for ws in "$workspaces_dir"/*/; do
+            [[ -d "$ws" ]] || continue
+            if [[ $has_workspaces -eq 0 ]]; then
+                {
+                    printf '\n'
+                    printf '## Active Workspaces\n'
+                    printf '\n'
+                } >> "$output"
+                has_workspaces=1
+            fi
+            local ws_name
+            ws_name=$(basename "$ws")
+            printf -- '- **%s** — `.revo/workspaces/%s/` (branch: feature/%s)\n' \
+                "$ws_name" "$ws_name" "$ws_name" >> "$output"
+        done
+        if [[ $has_workspaces -eq 1 ]]; then
+            {
+                printf '\n'
+                printf 'Run `revo workspaces` for branch/dirty status, or `cd` into one\n'
+                printf 'and run revo from there to operate on the workspace copy.\n'
+            } >> "$output"
+        fi
+    fi
+
     # Active features (any .revo/features/*.md files)
     local features_dir="$REVO_WORKSPACE_ROOT/.revo/features"
     if [[ -d "$features_dir" ]]; then
@@ -2978,6 +3046,8 @@ _context_write_file() {
         printf '6. Use `revo commit "msg"` to commit across all repos at once\n'
         printf '7. Use `revo feature <name>` to start a coordinated feature workspace\n'
         printf '8. Use `revo pr "title"` to open coordinated pull requests\n'
+        printf '9. Use `revo workspace <name>` to get a full-copy isolated workspace\n'
+        printf '   under `.revo/workspaces/<name>/` (zero bootstrap, .env included)\n'
         printf '\n'
         printf '## Workspace Tool: revo\n'
         printf '\n'
@@ -3002,6 +3072,26 @@ _context_write_file() {
         printf -- '- `revo exec "cmd" [--tag t]` — run command in filtered repos\n'
         printf -- '- `revo checkout <branch> [--tag t]` — switch branch across repos\n'
         printf '\n'
+        printf '**Workspaces (full-copy isolated workspaces):**\n'
+        printf -- '- `revo workspace <name> [--tag t]` — full copy of repos into `.revo/workspaces/<name>/` on `feature/<name>`\n'
+        printf -- '- `revo workspaces` — list active workspaces with branch and dirty state\n'
+        printf -- '- `revo workspace <name> --delete [--force]` — remove a workspace\n'
+        printf -- '- `revo workspace --clean` — remove workspaces whose branches are merged\n'
+        printf '\n'
+        printf 'Workspaces hardlink-copy everything (including `.env`, `node_modules`,\n'
+        printf 'build artifacts) so Claude can start work with zero bootstrap. Run\n'
+        printf '`revo` from inside `.revo/workspaces/<name>/` and it operates on the\n'
+        printf 'workspace copies, not the source tree.\n'
+        printf '\n'
+        printf '**Issues (cross-repo, via gh CLI):**\n'
+        printf -- '- `revo issue list [--tag t] [--state open|closed|all] [--label L] [--json]` — list issues across repos\n'
+        printf -- '- `revo issue create --repo <name> "title" [--body b] [--label L] [--feature F]` — create in one repo\n'
+        printf -- '- `revo issue create --tag <t> "title" [--body b] [--feature F]` — create in every matching repo, cross-referenced\n'
+        printf '\n'
+        printf 'Use `--json` on `revo issue list` to get a flat JSON array (each entry has\n'
+        printf 'a `repo` field) — easy to filter or pipe into jq when reasoning about\n'
+        printf 'cross-repo issue state.\n'
+        printf '\n'
         printf '### Tag filtering\n'
         printf '\n'
         printf 'All commands support `--tag <tag>` to target specific repos:\n'
@@ -3658,120 +3748,1212 @@ cmd_pr() {
     return 0
 }
 
-# === Main ===
-# --- Help ---
-show_help() {
-    cat << EOF
-Revo - Claude-first multi-repo workspace manager v$REVO_VERSION
+# === lib/commands/issue.sh ===
+# Revo CLI - issue command
+# List and create GitHub issues across workspace repos via the gh CLI.
 
-Usage: revo <command> [options]
+cmd_issue() {
+    local subcommand="${1:-}"
+    [[ $# -gt 0 ]] && shift
 
-Workspace commands:
-  init                        Initialize a new workspace (auto-detects existing repos)
-  detect                      Bootstrap revo around existing git repos in cwd
-  add URL [--tags TAGS]       Add a repository to the workspace
-  clone [--tag TAG]           Clone configured repositories
-  list [--tag TAG]            List configured repositories
-  status [--tag TAG]          Show status of all repositories
-  sync [--tag TAG]            Pull latest changes on repositories
-  branch NAME [--tag TAG]     Create a branch on repositories
-  checkout BRANCH [--tag TAG] Checkout a branch on repositories
-  exec "CMD" [--tag TAG]      Run a command in each repository
+    case "$subcommand" in
+        list|ls)
+            _issue_list "$@"
+            ;;
+        create|new)
+            _issue_create "$@"
+            ;;
+        --help|-h|help|"")
+            _issue_help
+            return 0
+            ;;
+        *)
+            ui_step_error "Unknown subcommand: $subcommand"
+            _issue_help
+            return 1
+            ;;
+    esac
+}
 
-Claude-first commands:
-  context                     Scan repos and regenerate workspace CLAUDE.md
-  feature NAME [--tag TAG]    Create feature branch + context file across repos
-  commit MSG [--tag TAG]      Commit changes across dirty repos
-  push [--tag TAG]            Push branches across repositories
-  pr TITLE [--tag TAG]        Create coordinated PRs via gh CLI
+_issue_help() {
+    cat << 'EOF'
+Usage: revo issue <subcommand> [options]
+
+Subcommands:
+  list                                    List issues across workspace repos
+  create                                  Create issue(s) in workspace repos
+
+revo issue list [options]
+  --tag TAG                Filter repos by tag
+  --state open|closed|all  Issue state (default: open)
+  --label LABEL            Filter by label
+  --limit N                Per-repo limit (default: 30)
+  --json                   Emit a flat JSON array (one entry per issue,
+                           with a "repo" field)
+
+revo issue create (--repo NAME | --tag TAG) "TITLE" [options]
+  --repo NAME              Target a single repo by path basename
+  --tag TAG                Target every repo matching the tag (cross-references
+                           all created issues in each body)
+  --body BODY              Issue body (default: revo-generated stub)
+  --label L,L              Comma-separated labels
+  --assignee USER          GitHub username to assign
+  --feature NAME           Append issue links to .revo/features/NAME.md and
+                           reference the brief from each issue body
+EOF
+}
 
-Options:
-  --tag TAG       Filter repositories by tag
-  --tags TAGS     Comma-separated list of tags (for add)
-  --force, -f     Force operation (clone, checkout)
-  --rebase, -r    Use rebase when syncing
-  --quiet, -q     Suppress command output (exec)
-  --body TEXT     PR body (pr)
-  --help, -h      Show this help
-  --version, -v   Show version
+# --- list ----------------------------------------------------------------
 
-Examples:
-  revo init
-  revo add git@github.com:org/shared-types.git --tags shared
-  revo add git@github.com:org/backend.git --tags backend,api
-  revo clone
-  revo context                                    # regenerate CLAUDE.md
-  revo feature clock-student --tag backend        # coordinated branch
-  revo commit "wire up clock endpoint"
-  revo push
-  revo pr "Clock endpoint for students" --tag backend
+_issue_list() {
+    local tag=""
+    local state="open"
+    local label=""
+    local limit="30"
+    local as_json=0
 
-Documentation: https://github.com/jippylong12/revo
-EOF
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --tag) tag="$2"; shift 2 ;;
+            --state) state="$2"; shift 2 ;;
+            --label) label="$2"; shift 2 ;;
+            --limit) limit="$2"; shift 2 ;;
+            --json) as_json=1; shift ;;
+            --help|-h) _issue_help; return 0 ;;
+            *) ui_step_error "Unknown option: $1"; return 1 ;;
+        esac
+    done
+
+    if ! command -v gh >/dev/null 2>&1; then
+        ui_step_error "gh CLI not found. Install from https://cli.github.com/"
+        return 1
+    fi
+
+    config_require_workspace || return 1
+
+    local repos
+    repos=$(config_get_repos "$tag")
+    if [[ -z "$repos" ]]; then
+        if [[ $as_json -eq 1 ]]; then
+            printf '[]\n'
+            return 0
+        fi
+        ui_step_error "No repositories configured"
+        return 1
+    fi
+
+    # Build the per-repo gh args once
+    local gh_extra=()
+    if [[ -n "$label" ]]; then
+        gh_extra+=( --label "$label" )
+    fi
+
+    if [[ $as_json -eq 1 ]]; then
+        _issue_list_json "$repos" "$state" "$limit" "${gh_extra[@]}"
+        return $?
+    fi
+
+    _issue_list_human "$repos" "$state" "$limit" "${gh_extra[@]}"
 }
 
-show_version() {
-    printf 'Revo v%s\n' "$REVO_VERSION"
+# Print a flat JSON array of issues across all repos. Each entry has a
+# "repo" field added in addition to the gh-provided fields. Output goes to
+# stdout, errors are silent (we want callers like Claude to be able to
+# pipe into jq).
+_issue_list_json() {
+    local repos="$1"
+    local state="$2"
+    local limit="$3"
+    shift 3
+    local gh_extra=( "$@" )
+
+    local entries=""
+    local first=1
+
+    local repo
+    while IFS= read -r repo; do
+        [[ -z "$repo" ]] && continue
+        local path
+        path=$(yaml_get_path "$repo")
+        local full_path="$REVO_REPOS_DIR/$path"
+        [[ ! -d "$full_path" ]] && continue
+
+        # gh's --jq runs the embedded jq engine and emits one compact JSON
+        # value per line by default. We map each issue, prepend a "repo"
+        # field, and stream the results into our concatenated array.
+        local lines
+        if lines=$(cd "$full_path" && gh issue list \
+            --state "$state" --limit "$limit" "${gh_extra[@]}" \
+            --json number,title,state,labels,assignees,url,updatedAt,author \
+            --jq ".[] | {repo: \"$path\"} + ." 2>/dev/null); then
+            local line
+            while IFS= read -r line; do
+                [[ -z "$line" ]] && continue
+                if [[ $first -eq 1 ]]; then
+                    entries="$line"
+                    first=0
+                else
+                    entries="$entries,$line"
+                fi
+            done <<< "$lines"
+        fi
+    done <<< "$repos"
+
+    printf '[%s]\n' "$entries"
+    return 0
 }
 
-# --- Main ---
-main() {
-    local command="${1:-}"
+# Print a human-readable per-repo summary of issues. Each repo gets its
+# own block separated by ui_bar_line.
+_issue_list_human() {
+    local repos="$1"
+    local state="$2"
+    local limit="$3"
+    shift 3
+    local gh_extra=( "$@" )
 
-    # Handle no arguments
-    if [[ -z "$command" ]]; then
-        show_help
-        return 0
+    ui_intro "Revo - Issues ($state)"
+
+    local total=0
+    local repo_count=0
+    local skip_count=0
+
+    local repo
+    while IFS= read -r repo; do
+        [[ -z "$repo" ]] && continue
+        local path
+        path=$(yaml_get_path "$repo")
+        local full_path="$REVO_REPOS_DIR/$path"
+
+        if [[ ! -d "$full_path" ]]; then
+            ui_step_done "Skipped (not cloned):" "$path"
+            skip_count=$((skip_count + 1))
+            continue
+        fi
+
+        ui_bar_line
+        ui_step "$path"
+
+        local count_output
+        if ! count_output=$(cd "$full_path" && gh issue list \
+            --state "$state" --limit "$limit" "${gh_extra[@]}" \
+            --json number --jq 'length' 2>&1); then
+            ui_step_error "Failed: $count_output"
+            continue
+        fi
+
+        local repo_total="${count_output:-0}"
+        if [[ "$repo_total" == "0" ]]; then
+            printf '%s  %s\n' "$(ui_bar)" "$(ui_dim "No $state issues")"
+            continue
+        fi
+
+        local pretty
+        if pretty=$(cd "$full_path" && gh issue list \
+            --state "$state" --limit "$limit" "${gh_extra[@]}" 2>&1); then
+            local line
+            while IFS= read -r line; do
+                printf '%s  %s\n' "$(ui_bar)" "$line"
+            done <<< "$pretty"
+        fi
+
+        total=$((total + repo_total))
+        repo_count=$((repo_count + 1))
+    done <<< "$repos"
+
+    ui_bar_line
+    local msg="Found $total issue(s) across $repo_count repo(s)"
+    [[ $skip_count -gt 0 ]] && msg+=", $skip_count skipped"
+    ui_outro "$msg"
+    return 0
+}
+
+# --- create --------------------------------------------------------------
+
+_issue_create() {
+    local title=""
+    local repo=""
+    local tag=""
+    local body=""
+    local labels=""
+    local assignee=""
+    local feature=""
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --repo) repo="$2"; shift 2 ;;
+            --tag) tag="$2"; shift 2 ;;
+            --body) body="$2"; shift 2 ;;
+            --label) labels="$2"; shift 2 ;;
+            --assignee) assignee="$2"; shift 2 ;;
+            --feature) feature="$2"; shift 2 ;;
+            --help|-h) _issue_help; return 0 ;;
+            -*) ui_step_error "Unknown option: $1"; return 1 ;;
+            *)
+                if [[ -z "$title" ]]; then
+                    title="$1"
+                else
+                    ui_step_error "Unexpected argument: $1"
+                    return 1
+                fi
+                shift
+                ;;
+        esac
+    done
+
+    if [[ -z "$title" ]]; then
+        ui_step_error "Usage: revo issue create (--repo NAME | --tag TAG) \"TITLE\""
+        return 1
     fi
 
-    # Shift off the command
-    shift || true
+    if [[ -z "$repo" ]] && [[ -z "$tag" ]]; then
+        ui_step_error "Either --repo or --tag is required"
+        return 1
+    fi
 
-    case "$command" in
-        init)
-            cmd_init "$@"
-            ;;
-        detect)
-            cmd_detect "$@"
-            ;;
-        clone)
-            cmd_clone "$@"
-            ;;
-        status)
-            cmd_status "$@"
-            ;;
-        branch)
-            cmd_branch "$@"
-            ;;
-        checkout)
-            cmd_checkout "$@"
-            ;;
-        sync)
-            cmd_sync "$@"
-            ;;
-        exec)
-            cmd_exec "$@"
-            ;;
-        add)
-            cmd_add "$@"
-            ;;
-        list)
-            cmd_list "$@"
-            ;;
-        context)
-            cmd_context "$@"
-            ;;
-        feature)
-            cmd_feature "$@"
-            ;;
-        commit)
-            cmd_commit "$@"
-            ;;
-        push)
-            cmd_push "$@"
-            ;;
-        pr)
-            cmd_pr "$@"
+    if [[ -n "$repo" ]] && [[ -n "$tag" ]]; then
+        ui_step_error "Use either --repo or --tag, not both"
+        return 1
+    fi
+
+    if ! command -v gh >/dev/null 2>&1; then
+        ui_step_error "gh CLI not found. Install from https://cli.github.com/"
+        return 1
+    fi
+
+    config_require_workspace || return 1
+
+    # Resolve target repo paths
+    local target_paths=()
+    if [[ -n "$repo" ]]; then
+        local idx
+        idx=$(yaml_find_by_name "$repo")
+        if [[ $idx -lt 0 ]]; then
+            ui_step_error "Repo not found in revo.yaml: $repo"
+            return 1
+        fi
+        target_paths+=("$repo")
+    else
+        local repos
+        repos=$(config_get_repos "$tag")
+        local r
+        while IFS= read -r r; do
+            [[ -z "$r" ]] && continue
+            local p
+            p=$(yaml_get_path "$r")
+            target_paths+=("$p")
+        done <<< "$repos"
+    fi
+
+    if [[ ${#target_paths[@]} -eq 0 ]]; then
+        ui_step_error "No matching repos"
+        return 1
+    fi
+
+    ui_intro "Revo - Create issue: $title"
+
+    # Validate feature brief if --feature was given
+    local feature_brief=""
+    if [[ -n "$feature" ]]; then
+        feature_brief="$REVO_WORKSPACE_ROOT/.revo/features/$feature.md"
+        if [[ ! -f "$feature_brief" ]]; then
+            ui_step_error "Feature brief not found: .revo/features/$feature.md"
+            ui_info "$(ui_dim "Run 'revo feature $feature' first to create it")"
+            return 1
+        fi
+    fi
+
+    # Build the initial body that all created issues share
+    local effective_body="$body"
+    if [[ -z "$effective_body" ]]; then
+        effective_body="Created by \`revo issue create\`."
+    fi
+    if [[ -n "$feature" ]]; then
+        effective_body="$effective_body"$'\n\n'"Part of feature: \`$feature\` (see \`.revo/features/$feature.md\`)"
+    fi
+
+    # --- Pass 1: create issues -------------------------------------------
+    local issue_paths=()
+    local issue_urls=()
+    local issue_numbers=()
+    local fail_count=0
+    local skip_count=0
+
+    local p
+    for p in "${target_paths[@]}"; do
+        local full_path="$REVO_REPOS_DIR/$p"
+
+        if [[ ! -d "$full_path" ]]; then
+            ui_step_done "Skipped (not cloned):" "$p"
+            skip_count=$((skip_count + 1))
+            continue
+        fi
+
+        local gh_args=( --title "$title" --body "$effective_body" )
+        if [[ -n "$labels" ]]; then
+            gh_args+=( --label "$labels" )
+        fi
+        if [[ -n "$assignee" ]]; then
+            gh_args+=( --assignee "$assignee" )
+        fi
+
+        local output
+        if output=$(cd "$full_path" && gh issue create "${gh_args[@]}" 2>&1); then
+            local url
+            url=$(printf '%s' "$output" | grep -Eo 'https://github\.com/[^ ]+/issues/[0-9]+' | tail -1)
+            if [[ -z "$url" ]]; then
+                url="$output"
+            fi
+            local number="${url##*/}"
+            issue_paths+=("$p")
+            issue_urls+=("$url")
+            issue_numbers+=("$number")
+            ui_step_done "Created:" "$p → $url"
+        else
+            ui_step_error "Failed: $p"
+            ui_info "$(ui_dim "$output")"
+            fail_count=$((fail_count + 1))
+        fi
+    done
+
+    # --- Pass 2: cross-references ----------------------------------------
+    if [[ ${#issue_paths[@]} -gt 1 ]]; then
+        ui_bar_line
+        ui_step "Linking issues with cross-references..."
+
+        local xref
+        xref=$'\n\n---\n**Coordinated issues (revo):**\n'
+        local i
+        for ((i = 0; i < ${#issue_paths[@]}; i++)); do
+            xref+="- ${issue_paths[$i]}: ${issue_urls[$i]}"$'\n'
+        done
+
+        for ((i = 0; i < ${#issue_paths[@]}; i++)); do
+            local repo_path="${issue_paths[$i]}"
+            local issue_number="${issue_numbers[$i]}"
+            local full_path="$REVO_REPOS_DIR/$repo_path"
+            local combined_body="$effective_body$xref"
+
+            if (cd "$full_path" && gh issue edit "$issue_number" --body "$combined_body" >/dev/null 2>&1); then
+                ui_step_done "Linked:" "$repo_path"
+            else
+                ui_step_error "Failed to link: $repo_path"
+            fi
+        done
+    fi
+
+    # --- Pass 3: append to feature brief ---------------------------------
+    if [[ -n "$feature_brief" ]] && [[ ${#issue_paths[@]} -gt 0 ]]; then
+        ui_bar_line
+        ui_step "Appending to feature brief: $feature"
+        {
+            printf '\n## Issues (created by revo)\n\n'
+            local i
+            for ((i = 0; i < ${#issue_paths[@]}; i++)); do
+                printf -- '- **%s**: %s\n' "${issue_paths[$i]}" "${issue_urls[$i]}"
+            done
+        } >> "$feature_brief"
+        ui_step_done "Updated:" ".revo/features/$feature.md"
+    fi
+
+    ui_bar_line
+
+    # Print URLs to stdout (LLM-friendly: one URL per line, parseable)
+    local i
+    for ((i = 0; i < ${#issue_urls[@]}; i++)); do
+        printf '%s\n' "${issue_urls[$i]}"
+    done
+
+    if [[ $fail_count -eq 0 ]]; then
+        local msg="Created ${#issue_paths[@]} issue(s)"
+        [[ $skip_count -gt 0 ]] && msg+=", $skip_count skipped"
+        ui_outro "$msg"
+        return 0
+    else
+        ui_outro_cancel "${#issue_paths[@]} created, $fail_count failed"
+        return 1
+    fi
+}
+
+# === lib/commands/workspace.sh ===
+# Revo CLI - workspace / workspaces commands
+# Full-copy workspaces under .revo/workspaces/<name>/. Unlike git worktrees
+# these copy *everything* — .env, node_modules, build artifacts — so Claude
+# can start work immediately with zero bootstrap. Hardlinks are used where
+# possible so the cost is near-zero on APFS/HFS+ and Linux.
+
+# --- helpers ---
+
+# Sanitize a workspace name: lowercase, hyphens for spaces, drop anything
+# that isn't [a-z0-9_-]. Keeps the resulting name safe to use as both a
+# directory name and a git branch suffix.
+_workspace_sanitize_name() {
+    local raw="$1"
+    local lowered
+    lowered=$(printf '%s' "$raw" | tr '[:upper:]' '[:lower:]')
+    lowered=$(printf '%s' "$lowered" | tr ' ' '-')
+    # Replace anything not a-z0-9-_ with -
+    lowered=$(printf '%s' "$lowered" | sed 's/[^a-z0-9_-]/-/g')
+    # Collapse runs of - and trim leading/trailing -
+    lowered=$(printf '%s' "$lowered" | sed -e 's/--*/-/g' -e 's/^-//' -e 's/-$//')
+    printf '%s' "$lowered"
+}
+
+# Verify .revo/ is in the workspace .gitignore. Workspaces hardlink-copy
+# everything, including .env files, so this is a hard requirement to avoid
+# accidentally committing secrets via the parent git repo (if any).
+# Returns 0 if safe, 1 if .revo/ is not gitignored.
+_workspace_verify_gitignore_safe() {
+    local gitignore="$REVO_WORKSPACE_ROOT/.gitignore"
+
+    # If the workspace root isn't itself a git repo, there's nothing to
+    # accidentally commit into. Treat as safe.
+    if [[ ! -d "$REVO_WORKSPACE_ROOT/.git" ]]; then
+        return 0
+    fi
+
+    if [[ ! -f "$gitignore" ]]; then
+        return 1
+    fi
+
+    # Match `.revo/`, `.revo`, `/.revo/`, `/.revo` — any of those works
+    awk '
+        { sub(/^[[:space:]]+/, ""); sub(/[[:space:]]+$/, "") }
+        $0 == ".revo" || $0 == ".revo/" || $0 == "/.revo" || $0 == "/.revo/" { found = 1; exit }
+        END { exit !found }
+    ' "$gitignore"
+}
+
+# Copy a source repo into the workspace. Tries hardlinks first
+# (`cp -RLl`), falls back to a regular recursive copy. Always follows
+# symlinks so init-style symlinked repos are materialized as real
+# directories inside the workspace.
+# Usage: _workspace_copy_repo "src" "dest"
+# Returns: 0 on success
+_workspace_copy_repo() {
+    local src="$1"
+    local dest="$2"
+
+    # Make sure parent exists, dest does not
+    mkdir -p "$(dirname "$dest")"
+    rm -rf "$dest" 2>/dev/null
+
+    # Try hardlinks first. -R recursive, -L follow symlinks, -l hardlink.
+    if cp -RLl "$src" "$dest" 2>/dev/null; then
+        return 0
+    fi
+
+    # Fall back to a real copy
+    rm -rf "$dest" 2>/dev/null
+    if cp -RL "$src" "$dest" 2>/dev/null; then
+        return 0
+    fi
+
+    return 1
+}
+
+# Print mtime in seconds-since-epoch for a path. Handles BSD (macOS) and
+# GNU (Linux) stat. Prints 0 if both fail.
+_workspace_mtime() {
+    local path="$1"
+    local mtime
+    if mtime=$(stat -f %m "$path" 2>/dev/null); then
+        printf '%s' "$mtime"
+        return 0
+    fi
+    if mtime=$(stat -c %Y "$path" 2>/dev/null); then
+        printf '%s' "$mtime"
+        return 0
+    fi
+    printf '0'
+}
+
+# Format an age in seconds as a short, human string ("2h", "3d", ...).
+_workspace_format_age() {
+    local secs="$1"
+    if [[ -z "$secs" ]] || [[ "$secs" -le 0 ]]; then
+        printf 'just now'
+        return
+    fi
+    if [[ "$secs" -lt 60 ]]; then
+        printf '%ds' "$secs"
+    elif [[ "$secs" -lt 3600 ]]; then
+        printf '%dm' $((secs / 60))
+    elif [[ "$secs" -lt 86400 ]]; then
+        printf '%dh' $((secs / 3600))
+    else
+        printf '%dd' $((secs / 86400))
+    fi
+}
+
+# Iterate the immediate subdirectories of a workspace dir that look like
+# git repos. Prints one path per line.
+# Usage: _workspace_repo_dirs "/abs/.revo/workspaces/foo"
+_workspace_repo_dirs() {
+    local ws_dir="$1"
+    local d
+    for d in "$ws_dir"/*/; do
+        [[ -d "$d" ]] || continue
+        d="${d%/}"
+        if [[ -d "$d/.git" ]] || [[ -f "$d/.git" ]]; then
+            printf '%s\n' "$d"
+        fi
+    done
+}
+
+# Returns 0 if the workspace has any repo with unpushed commits or
+# uncommitted changes. Used by --delete to require --force.
+_workspace_has_local_work() {
+    local ws_dir="$1"
+    local d
+    while IFS= read -r d; do
+        [[ -z "$d" ]] && continue
+        # Dirty working tree?
+        if [[ -n "$(git -C "$d" status --porcelain 2>/dev/null)" ]]; then
+            return 0
+        fi
+        # Any commits not present on any remote ref?
+        local unpushed
+        unpushed=$(git -C "$d" log --oneline --not --remotes 2>/dev/null | head -n 1)
+        if [[ -n "$unpushed" ]]; then
+            return 0
+        fi
+    done <<< "$(_workspace_repo_dirs "$ws_dir")"
+    return 1
+}
+
+# Returns 0 if every repo in the workspace has its current branch merged
+# into the workspace default branch (local or origin/<default>).
+# Workspaces with no repo dirs are not considered merged.
+_workspace_all_merged() {
+    local ws_dir="$1"
+    local default_branch="$2"
+    local any=0
+    local d
+    while IFS= read -r d; do
+        [[ -z "$d" ]] && continue
+        any=1
+        # Try local default branch first, then origin/<default>
+        if git -C "$d" merge-base --is-ancestor HEAD "$default_branch" 2>/dev/null; then
+            continue
+        fi
+        if git -C "$d" merge-base --is-ancestor HEAD "origin/$default_branch" 2>/dev/null; then
+            continue
+        fi
+        return 1
+    done <<< "$(_workspace_repo_dirs "$ws_dir")"
+    [[ $any -eq 1 ]]
+}
+
+# Generate a workspace-specific CLAUDE.md inside the workspace dir. Kept
+# intentionally short — the root workspace CLAUDE.md is the canonical
+# reference; this one just orients the agent inside the isolated copy.
+_workspace_write_claude_md() {
+    local name="$1"
+    local ws_dir="$2"
+    local branch="$3"
+    local target="$ws_dir/CLAUDE.md"
+    local timestamp
+    timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    local parent_name
+    parent_name=$(config_workspace_name)
+
+    {
+        printf '# revo workspace: %s\n' "$name"
+        printf '\n'
+        printf '> WARNING: This workspace contains .env files and other secrets\n'
+        printf '> hardlinked from the source repos. Never commit the .revo/\n'
+        printf '> directory.\n'
+        printf '\n'
+        printf -- '- **Branch:** %s\n' "$branch"
+        printf -- '- **Created:** %s\n' "$timestamp"
+        if [[ -n "$parent_name" ]]; then
+            printf -- '- **Parent workspace:** %s\n' "$parent_name"
+        fi
+        printf -- '- **Source:** ../../repos/\n'
+        printf '\n'
+        printf 'This is an isolated full-copy workspace. All edits, commits,\n'
+        printf 'and pushes happen here — the source tree under `repos/` is\n'
+        printf 'untouched. When you run `revo` from inside this directory it\n'
+        printf 'automatically operates on the repos under this workspace, not\n'
+        printf 'the source ones.\n'
+        printf '\n'
+        printf '## Repos\n'
+        printf '\n'
+
+        local d
+        while IFS= read -r d; do
+            [[ -z "$d" ]] && continue
+            local rname rbranch
+            rname=$(basename "$d")
+            rbranch=$(git -C "$d" rev-parse --abbrev-ref HEAD 2>/dev/null || printf '?')
+            printf '### %s\n' "$rname"
+            printf -- '- **Path:** ./%s\n' "$rname"
+            printf -- '- **Branch:** %s\n' "$rbranch"
+
+            scan_repo "$d"
+            if [[ -n "$SCAN_LANG" ]]; then
+                if [[ -n "$SCAN_NAME" ]]; then
+                    printf -- '- **Package:** %s (%s)\n' "$SCAN_NAME" "$SCAN_LANG"
+                else
+                    printf -- '- **Language:** %s\n' "$SCAN_LANG"
+                fi
+            fi
+            if [[ -n "$SCAN_FRAMEWORK" ]]; then
+                printf -- '- **Framework:** %s\n' "$SCAN_FRAMEWORK"
+            fi
+            if [[ -n "$SCAN_ROUTES" ]]; then
+                printf -- '- **API routes:** %s\n' "$SCAN_ROUTES"
+            fi
+            printf '\n'
+        done <<< "$(_workspace_repo_dirs "$ws_dir")"
+
+        printf '## Workflow\n'
+        printf '\n'
+        printf '1. Edit code across the repos above\n'
+        printf '2. `revo commit "msg"` to commit dirty repos in one shot\n'
+        printf '3. `revo push` to push branches\n'
+        printf '4. `revo pr "title"` to open coordinated PRs\n'
+        printf '5. After merge, `cd ../../.. && revo workspace %s --delete`\n' "$name"
+        printf '\n'
+        printf '## Workspace Tool: revo\n'
+        printf '\n'
+        printf 'See ../../CLAUDE.md (the parent workspace context) for the full\n'
+        printf 'revo command reference, dependency order, and per-repo details.\n'
+    } > "$target"
+}
+
+# --- create ---
+
+_workspace_create() {
+    local name="$1"
+    local tag="$2"
+    local force="$3"
+
+    local sanitized
+    sanitized=$(_workspace_sanitize_name "$name")
+    if [[ -z "$sanitized" ]]; then
+        ui_step_error "Invalid workspace name: $name"
+        return 1
+    fi
+
+    if [[ "$sanitized" != "$name" ]]; then
+        ui_info "$(ui_dim "Sanitized name: $name -> $sanitized")"
+    fi
+    name="$sanitized"
+
+    local branch="feature/$name"
+    local ws_root="$REVO_WORKSPACE_ROOT/.revo/workspaces"
+    local ws_dir="$ws_root/$name"
+
+    ui_intro "Revo - Create Workspace: $name"
+
+    if [[ -d "$ws_dir" ]]; then
+        ui_step_error "Workspace already exists: .revo/workspaces/$name"
+        ui_info "$(ui_dim "Use 'revo workspace $name --delete' to remove it first")"
+        ui_outro_cancel "Aborted"
+        return 1
+    fi
+
+    if ! _workspace_verify_gitignore_safe; then
+        ui_step_error ".revo/ is not in .gitignore at the workspace root"
+        ui_info "$(ui_dim "Workspaces hardlink-copy .env files and secrets — committing")"
+        ui_info "$(ui_dim ".revo/ would leak them. Add '.revo/' to .gitignore (or run 'revo init').")"
+        if [[ $force -ne 1 ]]; then
+            ui_info "$(ui_dim "Re-run with --force to override.")"
+            ui_outro_cancel "Aborted for safety"
+            return 1
+        fi
+        ui_step_error "Continuing anyway because --force was passed"
+    fi
+
+    local source_repos_dir
+    source_repos_dir=$(config_source_repos_dir)
+
+    local repos
+    repos=$(config_get_repos "$tag")
+
+    if [[ -z "$repos" ]]; then
+        if [[ -n "$tag" ]]; then
+            ui_step_error "No repositories match tag: $tag"
+        else
+            ui_step_error "No repositories configured"
+        fi
+        ui_outro_cancel "Nothing to copy"
+        return 1
+    fi
+
+    mkdir -p "$ws_dir"
+
+    local success_count=0
+    local skip_count=0
+    local fail_count=0
+
+    while IFS= read -r repo; do
+        [[ -z "$repo" ]] && continue
+
+        local path
+        path=$(yaml_get_path "$repo")
+        local src="$source_repos_dir/$path"
+        local dest="$ws_dir/$path"
+
+        if [[ ! -d "$src" ]]; then
+            ui_step_done "Skipped (not cloned):" "$path"
+            skip_count=$((skip_count + 1))
+            continue
+        fi
+
+        ui_spinner_start "Copying $path..."
+        if _workspace_copy_repo "$src" "$dest"; then
+            ui_spinner_stop
+            ui_step_done "Copied:" "$path"
+        else
+            ui_spinner_error "Failed to copy: $path"
+            fail_count=$((fail_count + 1))
+            continue
+        fi
+
+        # Check out the workspace branch in the copy
+        if git -C "$dest" rev-parse --verify "$branch" >/dev/null 2>&1; then
+            if git -C "$dest" checkout "$branch" >/dev/null 2>&1; then
+                ui_step_done "Checked out existing:" "$path -> $branch"
+            else
+                ui_step_error "Failed to checkout existing branch in: $path"
+                fail_count=$((fail_count + 1))
+                continue
+            fi
+        else
+            if git -C "$dest" checkout -b "$branch" >/dev/null 2>&1; then
+                ui_step_done "Branched:" "$path -> $branch"
+            else
+                ui_step_error "Failed to create branch in: $path"
+                fail_count=$((fail_count + 1))
+                continue
+            fi
+        fi
+
+        success_count=$((success_count + 1))
+    done <<< "$repos"
+
+    if [[ $success_count -eq 0 ]]; then
+        ui_outro_cancel "No repos copied; workspace cleanup needed"
+        rm -rf "$ws_dir" 2>/dev/null
+        return 1
+    fi
+
+    # Workspace-level CLAUDE.md
+    _workspace_write_claude_md "$name" "$ws_dir" "$branch"
+    ui_step_done "Wrote:" "$ws_dir/CLAUDE.md"
+
+    ui_bar_line
+
+    if [[ $fail_count -gt 0 ]]; then
+        ui_outro_cancel "Created with errors: $success_count ok, $fail_count failed"
+        return 1
+    fi
+
+    local msg="Workspace ready at .revo/workspaces/$name/"
+    ui_info "$(ui_dim "Branch: $branch  •  Repos: $success_count")"
+    if [[ $skip_count -gt 0 ]]; then
+        ui_info "$(ui_dim "$skip_count repo(s) skipped (not cloned in source)")"
+    fi
+    ui_info "$(ui_dim "cd .revo/workspaces/$name and run revo from there.")"
+    ui_outro "$msg"
+    return 0
+}
+
+# --- delete ---
+
+_workspace_delete() {
+    local name="$1"
+    local force="$2"
+
+    local sanitized
+    sanitized=$(_workspace_sanitize_name "$name")
+    name="$sanitized"
+
+    local ws_dir="$REVO_WORKSPACE_ROOT/.revo/workspaces/$name"
+
+    ui_intro "Revo - Delete Workspace: $name"
+
+    if [[ ! -d "$ws_dir" ]]; then
+        ui_step_error "No such workspace: $name"
+        ui_outro_cancel "Nothing to delete"
+        return 1
+    fi
+
+    if [[ $force -ne 1 ]] && _workspace_has_local_work "$ws_dir"; then
+        ui_step_error "Workspace has unpushed commits or uncommitted changes"
+        ui_info "$(ui_dim "Push or stash your work first, or re-run with --force to discard it.")"
+        ui_outro_cancel "Aborted"
+        return 1
+    fi
+
+    rm -rf "$ws_dir"
+
+    ui_step_done "Deleted:" ".revo/workspaces/$name"
+    ui_outro "Workspace removed"
+    return 0
+}
+
+# --- clean ---
+
+_workspace_clean() {
+    local ws_root="$REVO_WORKSPACE_ROOT/.revo/workspaces"
+
+    ui_intro "Revo - Clean Merged Workspaces"
+
+    if [[ ! -d "$ws_root" ]]; then
+        ui_info "No workspaces"
+        ui_outro "Nothing to clean"
+        return 0
+    fi
+
+    local default_branch
+    default_branch=$(config_default_branch)
+    [[ -z "$default_branch" ]] && default_branch="main"
+
+    local cleaned=0
+    local kept=0
+    local d
+    for d in "$ws_root"/*/; do
+        [[ -d "$d" ]] || continue
+        d="${d%/}"
+        local name
+        name=$(basename "$d")
+
+        if _workspace_all_merged "$d" "$default_branch"; then
+            rm -rf "$d"
+            ui_step_done "Removed (merged):" "$name"
+            cleaned=$((cleaned + 1))
+        else
+            ui_step_done "Kept:" "$name"
+            kept=$((kept + 1))
+        fi
+    done
+
+    ui_bar_line
+    ui_outro "Cleaned $cleaned, kept $kept"
+    return 0
+}
+
+# --- list (revo workspaces) ---
+
+cmd_workspaces() {
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --help|-h)
+                printf 'Usage: revo workspaces\n\n'
+                printf 'List all active workspaces with branch, age, and dirty state.\n'
+                return 0
+                ;;
+            *)
+                ui_step_error "Unknown option: $1"
+                return 1
+                ;;
+        esac
+    done
+
+    config_require_workspace || return 1
+
+    ui_intro "Revo - Workspaces"
+
+    local ws_root="$REVO_WORKSPACE_ROOT/.revo/workspaces"
+    if [[ ! -d "$ws_root" ]]; then
+        ui_info "No workspaces"
+        ui_bar_line
+        ui_info "$(ui_dim "Create one with: revo workspace <name>")"
+        ui_outro "Done"
+        return 0
+    fi
+
+    # Count first so we can short-circuit empty
+    local total=0
+    local d
+    for d in "$ws_root"/*/; do
+        [[ -d "$d" ]] || continue
+        total=$((total + 1))
+    done
+
+    if [[ $total -eq 0 ]]; then
+        ui_info "No workspaces"
+        ui_bar_line
+        ui_info "$(ui_dim "Create one with: revo workspace <name>")"
+        ui_outro "Done"
+        return 0
+    fi
+
+    ui_table_widths 24 24 8 7 12
+    ui_table_header "Workspace" "Branch" "Age" "Repos" "Dirty"
+
+    local now
+    now=$(date +%s)
+
+    for d in "$ws_root"/*/; do
+        [[ -d "$d" ]] || continue
+        d="${d%/}"
+        local name
+        name=$(basename "$d")
+
+        local mtime
+        mtime=$(_workspace_mtime "$d")
+        local age_secs=$((now - mtime))
+        local age
+        age=$(_workspace_format_age "$age_secs")
+
+        local repos_in_ws=0
+        local dirty_count=0
+        local branch=""
+        local repo
+        while IFS= read -r repo; do
+            [[ -z "$repo" ]] && continue
+            repos_in_ws=$((repos_in_ws + 1))
+            if [[ -z "$branch" ]]; then
+                branch=$(git -C "$repo" rev-parse --abbrev-ref HEAD 2>/dev/null || printf '?')
+            fi
+            if [[ -n "$(git -C "$repo" status --porcelain 2>/dev/null)" ]]; then
+                dirty_count=$((dirty_count + 1))
+            fi
+        done <<< "$(_workspace_repo_dirs "$d")"
+
+        [[ -z "$branch" ]] && branch="$(ui_dim "-")"
+
+        local dirty_text
+        if [[ $dirty_count -gt 0 ]]; then
+            dirty_text="$(ui_yellow "$dirty_count dirty")"
+        else
+            dirty_text="$(ui_green "clean")"
+        fi
+
+        ui_table_row "$name" "$branch" "$age" "$repos_in_ws" "$dirty_text"
+    done
+
+    ui_bar_line
+    ui_outro "$total workspace(s)"
+    return 0
+}
+
+# --- entry point: revo workspace ---
+
+cmd_workspace() {
+    local name=""
+    local tag=""
+    local action="create"
+    local force=0
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --tag)
+                tag="$2"
+                shift 2
+                ;;
+            --delete)
+                action="delete"
+                shift
+                ;;
+            --clean)
+                action="clean"
+                shift
+                ;;
+            --force|-f)
+                force=1
+                shift
+                ;;
+            --help|-h)
+                cat << 'EOF'
+Usage:
+  revo workspace <name> [--tag TAG]   Create a workspace (full copy of repos)
+  revo workspace <name> --delete [--force]
+                                       Delete a workspace
+  revo workspace --clean              Remove workspaces whose branches are merged
+  revo workspaces                     List active workspaces
+
+Workspaces are full copies of all repos (or a tagged subset) under
+.revo/workspaces/<name>/. Each workspace gets its own feature/<name>
+branch. Hardlinks are used where possible so the cost is near-zero.
+
+Run revo from inside .revo/workspaces/<name>/ and it automatically
+operates on the workspace's repos rather than the source tree.
+
+EOF
+                return 0
+                ;;
+            -*)
+                ui_step_error "Unknown option: $1"
+                return 1
+                ;;
+            *)
+                if [[ -z "$name" ]]; then
+                    name="$1"
+                else
+                    ui_step_error "Unexpected argument: $1"
+                    return 1
+                fi
+                shift
+                ;;
+        esac
+    done
+
+    config_require_workspace || return 1
+
+    case "$action" in
+        clean)
+            _workspace_clean
+            ;;
+        delete)
+            if [[ -z "$name" ]]; then
+                ui_step_error "Usage: revo workspace <name> --delete [--force]"
+                return 1
+            fi
+            _workspace_delete "$name" "$force"
+            ;;
+        create)
+            if [[ -z "$name" ]]; then
+                ui_step_error "Usage: revo workspace <name> [--tag TAG]"
+                return 1
+            fi
+            _workspace_create "$name" "$tag" "$force"
+            ;;
+    esac
+}
+
+# === Main ===
+# --- Help ---
+show_help() {
+    cat << EOF
+Revo - Claude-first multi-repo workspace manager v$REVO_VERSION
+
+Usage: revo <command> [options]
+
+Workspace commands:
+  init                        Initialize a new workspace (auto-detects existing repos)
+  detect                      Bootstrap revo around existing git repos in cwd
+  add URL [--tags TAGS]       Add a repository to the workspace
+  clone [--tag TAG]           Clone configured repositories
+  list [--tag TAG]            List configured repositories
+  status [--tag TAG]          Show status of all repositories
+  sync [--tag TAG]            Pull latest changes on repositories
+  branch NAME [--tag TAG]     Create a branch on repositories
+  checkout BRANCH [--tag TAG] Checkout a branch on repositories
+  exec "CMD" [--tag TAG]      Run a command in each repository
+
+Claude-first commands:
+  context                     Scan repos and regenerate workspace CLAUDE.md
+  feature NAME [--tag TAG]    Create feature branch + context file across repos
+  commit MSG [--tag TAG]      Commit changes across dirty repos
+  push [--tag TAG]            Push branches across repositories
+  pr TITLE [--tag TAG]        Create coordinated PRs via gh CLI
+  issue list [options]        List issues across workspace repos
+  issue create [options] TITLE Create issue(s) in workspace repos
+  workspace NAME [--tag TAG]  Create a full-copy workspace under .revo/workspaces/
+  workspace NAME --delete     Delete a workspace (use --force to discard work)
+  workspace --clean           Remove workspaces whose branches are merged
+  workspaces                  List active workspaces
+
+Options:
+  --tag TAG       Filter repositories by tag
+  --tags TAGS     Comma-separated list of tags (for add)
+  --force, -f     Force operation (clone, checkout)
+  --rebase, -r    Use rebase when syncing
+  --quiet, -q     Suppress command output (exec)
+  --body TEXT     PR body (pr)
+  --help, -h      Show this help
+  --version, -v   Show version
+
+Examples:
+  revo init
+  revo add git@github.com:org/shared-types.git --tags shared
+  revo add git@github.com:org/backend.git --tags backend,api
+  revo clone
+  revo context                                    # regenerate CLAUDE.md
+  revo feature clock-student --tag backend        # coordinated branch
+  revo commit "wire up clock endpoint"
+  revo push
+  revo pr "Clock endpoint for students" --tag backend
+  revo issue list --state open                       # all open issues
+  revo issue list --tag backend --json               # JSON for Claude/jq
+  revo issue create --repo backend "Add stats endpoint"
+  revo issue create --tag mobile --feature stats "Add statistics screen"
+  revo workspace clock-student                    # full copy of all repos
+  revo workspace clock-student --tag backend      # only backend repos
+  revo workspaces                                 # list active workspaces
+  revo workspace clock-student --delete           # remove when done
+
+Documentation: https://github.com/jippylong12/revo
+EOF
+}
+
+show_version() {
+    printf 'Revo v%s\n' "$REVO_VERSION"
+}
+
+# --- Main ---
+main() {
+    local command="${1:-}"
+
+    # Handle no arguments
+    if [[ -z "$command" ]]; then
+        show_help
+        return 0
+    fi
+
+    # Shift off the command
+    shift || true
+
+    case "$command" in
+        init)
+            cmd_init "$@"
+            ;;
+        detect)
+            cmd_detect "$@"
+            ;;
+        clone)
+            cmd_clone "$@"
+            ;;
+        status)
+            cmd_status "$@"
+            ;;
+        branch)
+            cmd_branch "$@"
+            ;;
+        checkout)
+            cmd_checkout "$@"
+            ;;
+        sync)
+            cmd_sync "$@"
+            ;;
+        exec)
+            cmd_exec "$@"
+            ;;
+        add)
+            cmd_add "$@"
+            ;;
+        list)
+            cmd_list "$@"
+            ;;
+        context)
+            cmd_context "$@"
+            ;;
+        feature)
+            cmd_feature "$@"
+            ;;
+        commit)
+            cmd_commit "$@"
+            ;;
+        push)
+            cmd_push "$@"
+            ;;
+        pr)
+            cmd_pr "$@"
+            ;;
+        issue|issues)
+            cmd_issue "$@"
+            ;;
+        workspace)
+            cmd_workspace "$@"
+            ;;
+        workspaces)
+            cmd_workspaces "$@"
             ;;
         --help|-h|help)
             show_help