claude-queue 1.4.0 → 1.5.1

package/README.md

@@ -1,8 +1,10 @@
 # claude-queue
 
-Automated GitHub issue solver. Queue up issues, let Claude Code solve them, wake up to a PR.
+A CLI tool that solves GitHub issues using [Claude Code](https://docs.anthropic.com/en/docs/claude-code). It picks up open issues from your repo, solves them one by one, and opens a pull request with all the fixes. It can also create well-structured GitHub issues from a text description or interactive interview.
 
-claude-queue fetches all open issues from your repo, uses [Claude Code](https://docs.anthropic.com/en/docs/claude-code) to solve each one, and opens a pull request with a summary of what was solved, what failed, and the full changelog.
+The typical workflow is: open issues for whatever you need done, run `claude-queue`, and come back to a pull request with everything solved. I usually do this at night and review the PR in the morning.
+
+Issues don't have to be code changes — they can be investigative tasks like "figure out why the API is slow and document what you find" or "audit the codebase for accessibility issues". Claude will research, document findings, and commit whatever it produces.
 
 ## Prerequisites
 
@@ -16,7 +18,7 @@ claude-queue fetches all open issues from your repo, uses [Claude Code](https://
 npm install -g claude-queue
 ```
 
-Or run directly with npx:
+Or run directly:
 
 ```bash
 npx claude-queue
@@ -24,23 +26,20 @@ npx claude-queue
 
 ## Usage
 
+### Solving issues
+
 Run from inside any git repository with GitHub issues:
 
 ```bash
 claude-queue
 ```
 
-### Options
-
 | Flag | Default | Description |
 |------|---------|-------------|
 | `--max-retries N` | `3` | Max retry attempts per issue before marking it failed |
-| `--max-turns N` | `50` | Max Claude Code turns per attempt (prevents runaway sessions) |
-| `--label LABEL` | all issues | Only process issues that have this label |
+| `--max-turns N` | `50` | Max Claude Code turns per attempt |
+| `--label LABEL` | all issues | Only process issues with this label |
 | `--model MODEL` | CLI default | Claude model to use (e.g. `claude-sonnet-4-5-20250929`) |
-| `-h, --help` | | Show help |
-
-### Examples
 
 ```bash
 # Solve all open issues
@@ -53,6 +52,48 @@ claude-queue --label bug
 claude-queue --max-retries 5 --model claude-sonnet-4-5-20250929
 ```
 
+### Creating issues
+
+Generate GitHub issues from a text description or an interactive interview with Claude.
+
+```bash
+claude-queue create "Add dark mode and fix the login bug"
+```
+
+There are three ways to provide input:
+
+1. **Inline text** — pass your description as an argument
+2. **Stdin** — run `claude-queue create` with no arguments, type or paste your text, then press Ctrl+D
+3. **Interactive** — run `claude-queue create -i` and Claude will ask clarifying questions before generating issues
+
+Claude decomposes the input into individual issues with titles, markdown bodies, and labels (reusing existing repo labels where possible). You get a preview before anything is created.
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `-i, --interactive` | off | Interview mode — Claude asks clarifying questions first |
+| `--label LABEL` | none | Add this label to every created issue |
+| `--model MODEL` | CLI default | Claude model to use |
+
+```bash
+# Interactive mode
+claude-queue create -i
+
+# Add a label to all created issues
+claude-queue create --label backlog "Refactor the auth module and add rate limiting"
+```
+
+### Create then solve workflow
+
+The `--label` flag on both commands lets you create a pipeline where `create` plans the issues and `claude-queue` solves them:
+
+```bash
+# Plan
+claude-queue create --label nightshift "Add dark mode and fix the login bug"
+
+# Solve
+claude-queue --label nightshift
+```
+
 ## Configuration
 
 Create a `.claude-queue` file in your repo root to add custom instructions to every issue prompt:
@@ -63,64 +104,58 @@ Use TypeScript strict mode.
 Never modify files in the src/legacy/ directory.
 ```
 
-These instructions are appended to the prompt Claude receives for each issue. This is useful for project-specific conventions that aren't captured in `CLAUDE.md`.
+These instructions are appended to the prompt Claude receives for each issue. Useful for project-specific conventions that aren't in `CLAUDE.md`.
 
 ## How It Works
 
-### 1. Preflight
+### Preflight
 
-Verifies all dependencies are available (`gh`, `claude`, `git`, `jq`), checks that `gh` is authenticated, and ensures the git working tree is clean. Aborts immediately if anything is missing.
+Verifies all dependencies (`gh`, `claude`, `git`, `jq`), checks that `gh` is authenticated, and ensures the working tree is clean.
 
-### 2. Label Setup
+### Label setup
 
 Creates three labels on the repo (skips if they already exist):
 
-| Label | Color | Meaning |
-|-------|-------|---------|
-| `claude-queue:in-progress` | Yellow | Currently being worked on |
-| `claude-queue:solved` | Green | Successfully fixed |
-| `claude-queue:failed` | Red | Could not be solved after all retries |
+| Label | Meaning |
+|-------|---------|
+| `claude-queue:in-progress` | Currently being worked on |
+| `claude-queue:solved` | Successfully fixed |
+| `claude-queue:failed` | Could not be solved after all retries |
 
-These labels let you see at a glance which issues were handled and what the outcome was.
+### Branching
 
-### 3. Branch
+Creates a branch `claude-queue/YYYY-MM-DD` off your default branch. All fixes go into this one branch. If the branch already exists, a timestamp suffix is added.
 
-Creates a single branch `claude-queue/YYYY-MM-DD` off your default branch. All fixes for the night go into this one branch. If the branch already exists (e.g. from a previous run), a timestamp suffix is added.
-
-### 4. Issue Processing
+### Issue processing
 
 For each open issue (up to 200, oldest first):
 
-- **Skip check** — issues that already have any `claude-queue:*` label are skipped. Remove the label to re-process.
-- **Label** — marks the issue `claude-queue:in-progress`
-- **Solve** — launches a fresh Claude Code process (`claude -p`) with a prompt that tells it to:
-  - Read the issue via `gh issue view`
-  - Explore the codebase
-  - Implement a fix
-  - Run existing tests
-- **Evaluate** — if Claude produced file changes, they are committed. If not, the attempt is retried.
-- **Retry** — on failure, the working tree is reset to the last checkpoint (`git reset --hard`) and Claude gets a completely fresh context. Up to 3 attempts per issue (configurable with `--max-retries`).
-- **Label result** — marks the issue `claude-queue:solved` or `claude-queue:failed`
+1. **Skip** — issues with any `claude-queue:*` label are skipped. Remove the label to re-process.
+2. **Label** — marks the issue `claude-queue:in-progress`.
+3. **Solve** — launches Claude Code with a prompt to read the issue, explore the codebase, implement a fix, and run tests.
+4. **Evaluate** — if Claude produced file changes, they are committed. If not, the attempt is retried.
+5. **Retry** — on failure, the working tree is reset and Claude gets a fresh context. Up to 3 attempts (configurable with `--max-retries`).
+6. **Result** — marks the issue `claude-queue:solved` or `claude-queue:failed`.
+
+Issues are solved sequentially so later fixes build on earlier ones within a single branch.
+
+### Review pass
 
-Each issue is solved sequentially so later fixes build on top of earlier ones — all in a single branch.
+After all issues are processed, Claude does a second pass reviewing all committed changes for bugs, incomplete implementations, and style issues — fixing anything it finds.
 
-### 5. Pull Request
+### Pull request
 
-Once all issues are processed, the branch is pushed and a PR is opened with:
+Once done, the branch is pushed and a PR is opened with:
 
-- **Summary table** — solved/failed/skipped counts and run duration
-- **Solved issues** — table of all issues that were fixed with links
-- **Failed issues** — table of issues that couldn't be solved
-- **Chain logs** — collapsible per-issue logs showing Claude's full output for each attempt
+- Summary table with solved/failed/skipped counts and run duration
+- Tables of solved and failed issues with links
+- Collapsible per-issue logs showing Claude's full output
 
-If no issues were solved, no PR is created.
+No PR is created if nothing was solved.
 
-### Interruption Handling
+### Interruption handling
 
-If the script is interrupted (Ctrl+C, SIGTERM), it:
-- Removes the `claude-queue:in-progress` label from the current issue
-- Marks it as `claude-queue:failed`
-- Prints where your commits and logs are so nothing is lost
+If interrupted (Ctrl+C, SIGTERM), the script removes the `claude-queue:in-progress` label from the current issue, marks it as failed, and prints where your commits and logs are.
 
 ## Logs
 
@@ -133,7 +168,7 @@ Full logs for each run are saved to `/tmp/claude-queue-DATE-TIMESTAMP/`:
 ├── issue-42-attempt-2.log  # Raw Claude output, attempt 2
 ├── issue-57.md
 ├── issue-57-attempt-1.log
-└── pr-body.md              # The generated PR description
+└── pr-body.md              # Generated PR description
 ```
 
 ## License

package/claude-queue.sh

@@ -1,20 +1,24 @@
 #!/usr/bin/env bash
 #
-# claude-queue - Automated GitHub issue solver
+# claude-queue - Automated GitHub issue solver & creator
 #
-# Fetches all open issues from the current repo, uses Claude Code CLI
-# to solve each one, and opens a PR in the morning with everything.
+# Commands:
+#   claude-queue [options]         Solve open issues (default)
+#   claude-queue create [options]  Create issues from text or interactively
 #
-# Usage:
-#   claude-queue [options]
-#
-# Options:
+# Solve options:
 #   --max-retries N    Max retries per issue (default: 3)
 #   --max-turns N      Max Claude turns per attempt (default: 50)
 #   --label LABEL      Only process issues with this label
 #   --model MODEL      Claude model to use
 #   -v, --version      Show version
 #   -h, --help         Show this help message
+#
+# Create options:
+#   -i, --interactive  Interview mode (Claude asks questions)
+#   --label LABEL      Add this label to all created issues
+#   --model MODEL      Claude model to use
+#   -h, --help         Show help for create
 
 set -euo pipefail
 
@@ -45,19 +49,41 @@ declare -a SOLVED_ISSUES=()
 declare -a FAILED_ISSUES=()
 declare -a SKIPPED_ISSUES=()
 CURRENT_ISSUE=""
+CHILD_PID=""
 START_TIME=$(date +%s)
 
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --max-retries) MAX_RETRIES="$2"; shift 2 ;;
-        --max-turns)   MAX_TURNS="$2";   shift 2 ;;
-        --label)       ISSUE_FILTER="$2"; shift 2 ;;
-        --model)       MODEL_FLAG="--model $2"; shift 2 ;;
-        -v|--version)  echo "claude-queue v${VERSION}"; exit 0 ;;
-        -h|--help)     head -16 "$0" | tail -14; exit 0 ;;
-        *)             echo "Unknown option: $1"; exit 1 ;;
-    esac
-done
+show_help() {
+    echo "claude-queue v${VERSION} — Automated GitHub issue solver & creator"
+    echo ""
+    echo "Usage:"
+    echo "  claude-queue [options]              Solve open issues (default)"
+    echo "  claude-queue create [options] [text] Create issues from text or interactively"
+    echo ""
+    echo "Solve options:"
+    echo "  --max-retries N    Max retries per issue (default: 3)"
+    echo "  --max-turns N      Max Claude turns per attempt (default: 50)"
+    echo "  --label LABEL      Only process issues with this label"
+    echo "  --model MODEL      Claude model to use"
+    echo "  -v, --version      Show version"
+    echo "  -h, --help         Show this help message"
+    echo ""
+    echo "Run 'claude-queue create --help' for create options."
+}
+
+show_create_help() {
+    echo "claude-queue create — Generate GitHub issues from text or an interactive interview"
+    echo ""
+    echo "Usage:"
+    echo "  claude-queue create \"description\"     Create issues from inline text"
+    echo "  claude-queue create                    Prompt for text input (Ctrl+D to finish)"
+    echo "  claude-queue create -i                 Interactive interview mode"
+    echo ""
+    echo "Options:"
+    echo "  -i, --interactive  Interview mode (Claude asks clarifying questions first)"
+    echo "  --label LABEL      Add this label to every created issue"
+    echo "  --model MODEL      Claude model to use"
+    echo "  -h, --help         Show this help message"
+}
 
 log()         { echo -e "${DIM}$(date +%H:%M:%S)${NC} ${BLUE}[claude-queue]${NC} $1"; }
 log_success() { echo -e "${DIM}$(date +%H:%M:%S)${NC} ${GREEN}[claude-queue]${NC} $1"; }
@@ -79,8 +105,21 @@ cleanup() {
         log_warn "Branch '${BRANCH}' has your commits. Push manually if needed."
     fi
 
-    log "Logs saved to: ${LOG_DIR}"
+    if [ -d "$LOG_DIR" ]; then
+        log "Logs saved to: ${LOG_DIR}"
+    fi
+}
+
+handle_interrupt() {
+    if [ -n "$CHILD_PID" ] && kill -0 "$CHILD_PID" 2>/dev/null; then
+        kill -TERM "$CHILD_PID" 2>/dev/null || true
+        wait "$CHILD_PID" 2>/dev/null || true
+    fi
+    CHILD_PID=""
+    exit 130
 }
+
+trap handle_interrupt INT TERM
 trap cleanup EXIT
 
 preflight() {
@@ -240,7 +279,10 @@ description of what you changed and why."
             --dangerously-skip-permissions \
             --max-turns "$MAX_TURNS" \
             $MODEL_FLAG \
-            > "$attempt_log" 2>&1 || claude_exit=$?
+            > "$attempt_log" 2>&1 &
+        CHILD_PID=$!
+        wait "$CHILD_PID" || claude_exit=$?
+        CHILD_PID=""
 
         if [ "$claude_exit" -ne 0 ]; then
             log_warn "Claude exited with code ${claude_exit}"
@@ -350,7 +392,10 @@ When you are done, output a line that says CLAUDE_QUEUE_REVIEW followed by a bri
         --dangerously-skip-permissions \
         --max-turns "$MAX_TURNS" \
         $MODEL_FLAG \
-        > "$review_log" 2>&1 || true
+        > "$review_log" 2>&1 &
+    CHILD_PID=$!
+    wait "$CHILD_PID" 2>/dev/null || true
+    CHILD_PID=""
 
     local changed_files
     changed_files=$(git diff --name-only 2>/dev/null; git ls-files --others --exclude-standard 2>/dev/null)
@@ -536,4 +581,392 @@ main() {
     log "Logs: ${LOG_DIR}"
 }
 
-main "$@"
+create_preflight() {
+    log_header "Preflight Checks"
+
+    local failed=false
+
+    for cmd in gh claude jq; do
+        if command -v "$cmd" &>/dev/null; then
+            log "  $cmd ... found"
+        else
+            log_error "  $cmd ... NOT FOUND"
+            failed=true
+        fi
+    done
+
+    if ! gh auth status &>/dev/null; then
+        log_error "  gh auth ... not authenticated"
+        failed=true
+    else
+        log "  gh auth ... ok"
+    fi
+
+    if ! git rev-parse --is-inside-work-tree &>/dev/null; then
+        log_error "  git repo ... not inside a git repository"
+        failed=true
+    else
+        log "  git repo ... ok"
+    fi
+
+    if [ "$failed" = true ]; then
+        log_error "Preflight failed. Aborting."
+        exit 1
+    fi
+}
+
+get_repo_labels() {
+    gh label list --json name -q '.[].name' 2>/dev/null | paste -sd ',' -
+}
+
+extract_json() {
+    local input="$1"
+    local json
+
+    json=$(echo "$input" | sed -n '/^```\(json\)\?$/,/^```$/{ /^```/d; p; }')
+    if [ -z "$json" ]; then
+        json="$input"
+    fi
+
+    if echo "$json" | jq empty 2>/dev/null; then
+        echo "$json"
+        return 0
+    fi
+
+    json=$(echo "$input" | grep -o '\[.*\]' | head -1)
+    if [ -n "$json" ] && echo "$json" | jq empty 2>/dev/null; then
+        echo "$json"
+        return 0
+    fi
+
+    return 1
+}
+
+create_from_text() {
+    local user_text="$1"
+    local repo_labels
+    repo_labels=$(get_repo_labels)
+
+    log "Analyzing text and generating issues..."
+
+    local prompt
+    prompt="You are a GitHub issue planner. The user wants to create issues for a repository.
+
+Existing labels in the repo: ${repo_labels}
+
+The user's description:
+${user_text}
+
+Decompose this into a JSON array of well-structured GitHub issues. Each issue should have:
+- \"title\": a clear, concise issue title
+- \"body\": a detailed issue body in markdown (include acceptance criteria where appropriate)
+- \"labels\": an array of label strings (reuse existing repo labels when they fit, or suggest new ones)
+
+Rules:
+- Create separate issues for logically distinct tasks
+- Each issue should be independently actionable
+- Use clear, imperative titles (e.g. \"Add dark mode toggle to settings page\")
+- If the description is vague, make reasonable assumptions and note them in the body
+
+Output ONLY the JSON array, no other text."
+
+    local output
+    # shellcheck disable=SC2086
+    output=$(claude -p "$prompt" $MODEL_FLAG 2>/dev/null)
+
+    local json
+    if ! json=$(extract_json "$output"); then
+        log_error "Failed to parse Claude's response as JSON"
+        log_error "Raw output:"
+        echo "$output"
+        exit 1
+    fi
+
+    local count
+    count=$(echo "$json" | jq length)
+    if [ "$count" -eq 0 ]; then
+        log_error "No issues were generated"
+        exit 1
+    fi
+
+    echo "$json"
+}
+
+create_interactive() {
+    local repo_labels
+    repo_labels=$(get_repo_labels)
+    local conversation=""
+    local max_turns=10
+    local turn=0
+
+    local system_prompt="You are a GitHub issue planner conducting an interview to understand what issues to create for a repository.
+
+Existing labels in the repo: ${repo_labels}
+
+Your job:
+1. Ask focused questions to understand what the user wants to build or fix
+2. Ask about priorities, scope, and acceptance criteria
+3. When you have enough information, output the marker CLAUDE_QUEUE_READY on its own line, followed by a JSON array of issues
+
+Each issue in the JSON array should have:
+- \"title\": a clear, concise issue title
+- \"body\": a detailed issue body in markdown
+- \"labels\": an array of label strings (reuse existing repo labels when they fit)
+
+Rules:
+- Ask one question at a time
+- Keep questions short and specific
+- After 2-3 questions you should have enough context — don't over-interview
+- If the user says \"done\", immediately generate the issues with what you know
+- Output ONLY your question text (no JSON) until you're ready to generate issues
+- When ready, output CLAUDE_QUEUE_READY on its own line followed by ONLY the JSON array"
+
+    echo -e "${BOLD}Interactive issue creation${NC}"
+    echo -e "${DIM}Answer Claude's questions. Type 'done' to generate issues at any time.${NC}"
+    echo ""
+
+    while [ "$turn" -lt "$max_turns" ]; do
+        turn=$((turn + 1))
+
+        local prompt
+        if [ -z "$conversation" ]; then
+            prompt="${system_prompt}
+
+Start by asking your first question."
+        else
+            prompt="${system_prompt}
+
+Conversation so far:
+${conversation}
+
+Continue the interview or, if you have enough information, output CLAUDE_QUEUE_READY followed by the JSON array."
+        fi
+
+        local output
+        # shellcheck disable=SC2086
+        output=$(claude -p "$prompt" $MODEL_FLAG 2>/dev/null)
+
+        if echo "$output" | grep -q "CLAUDE_QUEUE_READY"; then
+            local json_part
+            json_part=$(echo "$output" | sed -n '/CLAUDE_QUEUE_READY/,$ p' | tail -n +2)
+
+            local json
+            if ! json=$(extract_json "$json_part"); then
+                log_error "Failed to parse generated issues as JSON"
+                exit 1
+            fi
+
+            echo "$json"
+            return 0
+        fi
+
+        echo -e "${BLUE}Claude:${NC} ${output}"
+        echo ""
+
+        local user_input
+        read -r -p "You: " user_input
+
+        if [ "$user_input" = "done" ]; then
+            conversation="${conversation}
+Claude: ${output}
+User: Please generate the issues now with what you know."
+
+            local final_prompt="${system_prompt}
+
+Conversation so far:
+${conversation}
+
+The user wants you to generate the issues now. Output CLAUDE_QUEUE_READY followed by the JSON array."
+
+            local final_output
+            # shellcheck disable=SC2086
+            final_output=$(claude -p "$final_prompt" $MODEL_FLAG 2>/dev/null)
+
+            local final_json_part
+            final_json_part=$(echo "$final_output" | sed -n '/CLAUDE_QUEUE_READY/,$ p' | tail -n +2)
+            if [ -z "$final_json_part" ]; then
+                final_json_part="$final_output"
+            fi
+
+            local json
+            if ! json=$(extract_json "$final_json_part"); then
+                log_error "Failed to parse generated issues as JSON"
+                exit 1
+            fi
+
+            echo "$json"
+            return 0
+        fi
+
+        conversation="${conversation}
+Claude: ${output}
+User: ${user_input}"
+    done
+
+    log_warn "Reached maximum interview turns, generating issues with current information..."
+
+    local final_prompt="${system_prompt}
+
+Conversation so far:
+${conversation}
+
+You've reached the maximum number of questions. Output CLAUDE_QUEUE_READY followed by the JSON array now."
+
+    local final_output
+    # shellcheck disable=SC2086
+    final_output=$(claude -p "$final_prompt" $MODEL_FLAG 2>/dev/null)
+
+    local final_json_part
+    final_json_part=$(echo "$final_output" | sed -n '/CLAUDE_QUEUE_READY/,$ p' | tail -n +2)
+    if [ -z "$final_json_part" ]; then
+        final_json_part="$final_output"
+    fi
+
+    local json
+    if ! json=$(extract_json "$final_json_part"); then
+        log_error "Failed to parse generated issues as JSON"
+        exit 1
+    fi
+
+    echo "$json"
+}
+
+preview_issues() {
+    local json="$1"
+    local count
+    count=$(echo "$json" | jq length)
+
+    echo ""
+    echo -e "${BOLD}═══ Issue Preview ═══${NC}"
+    echo ""
+
+    for i in $(seq 0 $((count - 1))); do
+        local title labels body
+        title=$(echo "$json" | jq -r ".[$i].title")
+        labels=$(echo "$json" | jq -r ".[$i].labels // [] | join(\", \")")
+        body=$(echo "$json" | jq -r ".[$i].body" | head -3)
+
+        echo -e "  ${BOLD}$((i + 1)). ${title}${NC}"
+        if [ -n "$labels" ]; then
+            echo -e "     ${DIM}Labels: ${labels}${NC}"
+        fi
+        echo -e "     ${DIM}$(echo "$body" | head -1)${NC}"
+        echo ""
+    done
+}
+
+confirm_and_create() {
+    local json="$1"
+    local extra_label="$2"
+    local count
+    count=$(echo "$json" | jq length)
+
+    local prompt_text="Create ${count} issue(s)? [y/N] "
+    read -r -p "$prompt_text" confirm
+
+    if [[ ! "$confirm" =~ ^[Yy]$ ]]; then
+        log "Cancelled."
+        exit 0
+    fi
+
+    echo ""
+
+    for i in $(seq 0 $((count - 1))); do
+        local title body
+        title=$(echo "$json" | jq -r ".[$i].title")
+        body=$(echo "$json" | jq -r ".[$i].body")
+
+        local label_args=()
+        local issue_labels
+        issue_labels=$(echo "$json" | jq -r ".[$i].labels // [] | .[]")
+        while IFS= read -r lbl; do
+            if [ -n "$lbl" ]; then
+                label_args+=(--label "$lbl")
+            fi
+        done <<< "$issue_labels"
+
+        if [ -n "$extra_label" ]; then
+            label_args+=(--label "$extra_label")
+        fi
+
+        local issue_url
+        issue_url=$(gh issue create --title "$title" --body "$body" "${label_args[@]}" 2>&1)
+        log_success "Created: ${issue_url}"
+    done
+
+    echo ""
+    log_success "Created ${count} issue(s)"
+}
+
+cmd_create() {
+    local interactive=false
+    local extra_label=""
+    local user_text=""
+
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            -i|--interactive) interactive=true; shift ;;
+            --label)          extra_label="$2"; shift 2 ;;
+            --model)          MODEL_FLAG="--model $2"; shift 2 ;;
+            -h|--help)        show_create_help; exit 0 ;;
+            -*)               echo "Unknown option: $1"; echo ""; show_create_help; exit 1 ;;
+            *)                user_text="$1"; shift ;;
+        esac
+    done
+
+    create_preflight
+
+    local json
+
+    if [ "$interactive" = true ]; then
+        json=$(create_interactive)
+    elif [ -n "$user_text" ]; then
+        json=$(create_from_text "$user_text")
+    else
+        echo -e "${BOLD}Describe what issues you want to create.${NC}"
+        echo -e "${DIM}Type or paste your text, then press Ctrl+D when done.${NC}"
+        echo ""
+        user_text=$(cat)
+        if [ -z "$user_text" ]; then
+            log_error "No input provided"
+            exit 1
+        fi
+        json=$(create_from_text "$user_text")
+    fi
+
+    preview_issues "$json"
+    confirm_and_create "$json" "$extra_label"
+}
+
+# --- Subcommand routing ---
+
+SUBCOMMAND=""
+if [[ $# -gt 0 ]] && [[ "$1" != -* ]]; then
+    SUBCOMMAND="$1"; shift
+fi
+
+case "$SUBCOMMAND" in
+    "")
+        while [[ $# -gt 0 ]]; do
+            case $1 in
+                --max-retries) MAX_RETRIES="$2"; shift 2 ;;
+                --max-turns)   MAX_TURNS="$2";   shift 2 ;;
+                --label)       ISSUE_FILTER="$2"; shift 2 ;;
+                --model)       MODEL_FLAG="--model $2"; shift 2 ;;
+                -v|--version)  echo "claude-queue v${VERSION}"; exit 0 ;;
+                -h|--help)     show_help; exit 0 ;;
+                *)             echo "Unknown option: $1"; exit 1 ;;
+            esac
+        done
+        main
+        ;;
+    create)
+        cmd_create "$@"
+        ;;
+    *)
+        echo "Unknown command: $SUBCOMMAND"
+        echo ""
+        show_help
+        exit 1
+        ;;
+esac

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-queue",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "Automated GitHub issue solver powered by Claude Code",
   "bin": {
     "claude-queue": "./claude-queue.sh"