Feature request: Add --editor and --ai flags to 'new' command

[echarrod]

Summary

After running git gtr new <branch>, the tool displays helpful "Next steps" suggesting commands to open an editor or start an AI tool:

Next steps:
  git gtr editor MyBranch  # Open in editor
  git gtr ai MyBranch      # Start AI tool
  cd "$(git gtr go MyBranch)"  # Navigate to worktree

It would be convenient to have flags that automatically perform these actions, avoiding the need to copy/paste a second command.

Proposed Solution

Add optional flags to git gtr new:

• --editor or -e: Automatically open the configured editor after worktree creation
• --ai or -a: Automatically start the configured AI tool after worktree creation

Example usage

# Create worktree and immediately open in editor
git gtr new my-feature --editor

# Create worktree and start AI tool
git gtr new my-feature --ai

# Both could potentially be combined
git gtr new my-feature --editor --ai

--cd flag

Wanted to also suggest adding a --cd flag to change directory, but I think this is tricky since a subprocess can't change the parent shell's directory.

Benefits

1. Faster workflow - Common two-step actions become single commands
2. Scriptable - Easier to automate worktree creation with immediate editor/AI startup
3. Consistent with existing patterns - Similar to how git clone has --branch to do extra work

Questions for maintainers

1. Does this align with the project's philosophy of "configuration over flags"?
2. Should these be position-independent flags or positional options?
3. Any concerns about flag naming conflicts?

Happy to implement this if the approach is approved!

[traycerai]

Plan

Observations

The codebase is a well-structured Bash-based CLI tool for managing git worktrees with approximately 1,300 lines in the main script. The cmd_create function (lines 113-294) currently displays "Next steps" suggestions after worktree creation. The cmd_editor and cmd_ai functions are already implemented with flag support (--editor and --ai). The flag parsing pattern is consistent across commands using case statements. Shell completions exist for bash, zsh, and fish. The project emphasizes cross-platform compatibility and a "configuration over flags" philosophy.

Approach

The implementation will add --editor (short: -e) and --ai (short: -a) flags to the new command that automatically invoke the respective commands after worktree creation. This aligns with the existing flag patterns and provides a streamlined workflow. The flags will be optional and can be combined. The "Next steps" message will be conditionally displayed based on which flags were used. Completions will be updated to include the new flags, and help documentation will reflect the new options.

Implementation Steps

1. Update cmd_create function in bin/gtr

Add flag variables (after line 124):

• Add local auto_editor="" to store the editor name
• Add local auto_ai="" to store the AI tool name

Extend flag parsing (in the while loop starting at line 127):

• Add case for --editor|-e) that captures the next argument and stores in auto_editor, then shift 2
• Add case for --ai|-a) that captures the next argument and stores in auto_ai, then shift 2
• Position these new cases before the -*) unknown flag handler

Invoke editor after worktree creation (after line 285, before the "Next steps" message):

• Check if auto_editor is not empty
• If set, call the editor opening logic similar to cmd_editor:
  • Get editor from auto_editor or fall back to config using cfg_default
  • Load the editor adapter using load_editor_adapter
  • Call editor_open "$worktree_path"
  • Handle errors gracefully with log messages

Invoke AI tool after editor (after the editor invocation):

• Check if auto_ai is not empty
• If set, call the AI tool logic similar to cmd_ai:
  • Get AI tool from auto_ai or fall back to config using cfg_default
  • Validate that AI tool is not "none"
  • Load the AI adapter using load_ai_adapter
  • Call ai_start "$worktree_path"
  • Handle errors gracefully with log messages

Update "Next steps" message (lines 290-293):

• Make the message conditional based on which flags were used
• If --editor was used, omit the editor line from suggestions
• If --ai was used, omit the AI line from suggestions
• If both were used, only show the cd navigation suggestion
• Keep the message helpful for users who didn't use the flags

2. Update bash completion in completions/gtr.bash

Modify the new command completion (line 62):

• Add --editor and -e to the flag list
• Add --ai and -a to the flag list
• The updated line should include: --editor -e --ai -a along with existing flags

Add completion for flag values (after line 64):

• Add case for --editor|-e that completes with available editors: cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none
• Add case for --ai|-a that completes with available AI tools: aider claude codex continue copilot cursor gemini opencode none

3. Update zsh completion in completions/_git-gtr

Extend the new command arguments (lines 44-54):

• Add '--editor[Open in editor after creation]:editor:(cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none)'
• Add '-e[Open in editor after creation]:editor:(cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none)'
• Add '--ai[Start AI tool after creation]:tool:(aider claude codex continue copilot cursor gemini opencode none)'
• Add '-a[Start AI tool after creation]:tool:(aider claude codex continue copilot cursor gemini opencode none)'

4. Update fish completion in completions/gtr.fish

Add flag completions for the new command:

• Add completion for --editor and -e with editor options
• Add completion for --ai and -a with AI tool options
• Follow the existing fish completion syntax pattern

5. Update help documentation in bin/gtr

Update the new command description (around line 1164):

• Add --editor <name>, -e <name>: open in editor after creation to the options list
• Add --ai <name>, -a <name>: start AI tool after creation to the options list
• Position these after the existing flags but before --yes

Add workflow example (in the WORKFLOW EXAMPLES section around line 1270):

• Add example: git gtr new my-feature --editor cursor --ai claude # Create and start working immediately
• Add example: git gtr new hotfix -e vscode # Quick shorthand

6. Update README.md documentation

Update the new command section:

• Add the new flags to the options list with descriptions
• Include examples showing the combined usage:
  • git gtr new my-feature --editor cursor
  • git gtr new my-feature --ai claude
  • git gtr new my-feature -e cursor -a claude

Update the Quick Start section:

• Consider adding an example showing the streamlined workflow with the new flags

Implementation Flow

User runs: git gtr new my-feature --editor cursor --ai claude
↓
cmd_create() parses flags (--editor, --ai)
↓
Creates worktree
↓
Copies files (if not --no-copy)
↓
Runs postCreate hooks
↓
If --editor flag provided:

• Load editor adapter (cursor)
• Call editor_open(worktree_path)
  ↓
  If --ai flag provided:
• Load AI adapter (claude)
• Call ai_start(worktree_path)
  ↓
  Display conditional "Next steps" message

Key Considerations

Aspect	Decision	Rationale
Flag naming	--editor/-e and --ai/-a	Consistent with existing editor and ai commands; short forms for convenience
Flag values	Optional (use config default if omitted)	Allows git gtr new feature -e to use configured editor
Error handling	Non-fatal errors with warnings	If editor/AI fails to open, still show success message for worktree creation
Execution order	Editor before AI	Logical workflow: open editor first, then start AI tool
Message updates	Conditional display	Only show suggestions for actions not already performed
Backwards compatibility	Fully maintained	New flags are optional; existing workflows unchanged
Philosophy alignment	Flags are optional shortcuts	Aligns with "configuration over flags" - users can set defaults once, then use -e and -a as convenient shortcuts

Testing Checklist

• Test git gtr new feature --editor cursor opens editor after creation
• Test git gtr new feature --ai claude starts AI tool after creation
• Test git gtr new feature -e vscode -a aider combines both flags
• Test git gtr new feature -e uses default editor from config
• Test git gtr new feature --editor cursor --ai claude combines both flags with full names
• Test error handling when editor/AI tool not found
• Test that "Next steps" message adapts based on flags used (omits lines for actions already performed)
• Test that "Next steps" message shows all suggestions when no flags are used
• Verify tab completion works for new flags in bash, zsh, and fish
• Test on macOS, Linux, and Windows Git Bash if possible
• Verify help text displays new options correctly
• Test that worktree is created successfully even if editor/AI startup fails
• Test flag position independence (flags can appear before or after branch name)

Import In IDE

🤖 Prompt for AI Agents

## Observations

The codebase is a well-structured Bash-based CLI tool for managing git worktrees with approximately 1,300 lines in the main script. The `cmd_create` function (lines 113-294) currently displays "Next steps" suggestions after worktree creation. The `cmd_editor` and `cmd_ai` functions are already implemented with flag support (`--editor` and `--ai`). The flag parsing pattern is consistent across commands using case statements. Shell completions exist for bash, zsh, and fish. The project emphasizes cross-platform compatibility and a "configuration over flags" philosophy.

## Approach

The implementation will add `--editor` (short: `-e`) and `--ai` (short: `-a`) flags to the `new` command that automatically invoke the respective commands after worktree creation. This aligns with the existing flag patterns and provides a streamlined workflow. The flags will be optional and can be combined. The "Next steps" message will be conditionally displayed based on which flags were used. Completions will be updated to include the new flags, and help documentation will reflect the new options.

## Implementation Steps

### 1. Update `cmd_create` function in bin/gtr

**Add flag variables** (after line 124):
- Add `local auto_editor=""` to store the editor name
- Add `local auto_ai=""` to store the AI tool name

**Extend flag parsing** (in the while loop starting at line 127):
- Add case for `--editor|-e)` that captures the next argument and stores in `auto_editor`, then `shift 2`
- Add case for `--ai|-a)` that captures the next argument and stores in `auto_ai`, then `shift 2`
- Position these new cases before the `-*)` unknown flag handler

**Invoke editor after worktree creation** (after line 285, before the "Next steps" message):
- Check if `auto_editor` is not empty
- If set, call the editor opening logic similar to `cmd_editor`:
  - Get editor from `auto_editor` or fall back to config using `cfg_default`
  - Load the editor adapter using `load_editor_adapter`
  - Call `editor_open "$worktree_path"`
  - Handle errors gracefully with log messages

**Invoke AI tool after editor** (after the editor invocation):
- Check if `auto_ai` is not empty
- If set, call the AI tool logic similar to `cmd_ai`:
  - Get AI tool from `auto_ai` or fall back to config using `cfg_default`
  - Validate that AI tool is not "none"
  - Load the AI adapter using `load_ai_adapter`
  - Call `ai_start "$worktree_path"`
  - Handle errors gracefully with log messages

**Update "Next steps" message** (lines 290-293):
- Make the message conditional based on which flags were used
- If `--editor` was used, omit the editor line from suggestions
- If `--ai` was used, omit the AI line from suggestions
- If both were used, only show the `cd` navigation suggestion
- Keep the message helpful for users who didn't use the flags

### 2. Update bash completion in completions/gtr.bash

**Modify the `new` command completion** (line 62):
- Add `--editor` and `-e` to the flag list
- Add `--ai` and `-a` to the flag list
- The updated line should include: `--editor -e --ai -a` along with existing flags

**Add completion for flag values** (after line 64):
- Add case for `--editor|-e` that completes with available editors: `cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none`
- Add case for `--ai|-a` that completes with available AI tools: `aider claude codex continue copilot cursor gemini opencode none`

### 3. Update zsh completion in completions/_git-gtr

**Extend the `new` command arguments** (lines 44-54):
- Add `'--editor[Open in editor after creation]:editor:(cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none)'`
- Add `'-e[Open in editor after creation]:editor:(cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none)'`
- Add `'--ai[Start AI tool after creation]:tool:(aider claude codex continue copilot cursor gemini opencode none)'`
- Add `'-a[Start AI tool after creation]:tool:(aider claude codex continue copilot cursor gemini opencode none)'`

### 4. Update fish completion in completions/gtr.fish

**Add flag completions for the `new` command**:
- Add completion for `--editor` and `-e` with editor options
- Add completion for `--ai` and `-a` with AI tool options
- Follow the existing fish completion syntax pattern

### 5. Update help documentation in bin/gtr

**Update the `new` command description** (around line 1164):
- Add `--editor <name>, -e <name>: open in editor after creation` to the options list
- Add `--ai <name>, -a <name>: start AI tool after creation` to the options list
- Position these after the existing flags but before `--yes`

**Add workflow example** (in the WORKFLOW EXAMPLES section around line 1270):
- Add example: `git gtr new my-feature --editor cursor --ai claude  # Create and start working immediately`
- Add example: `git gtr new hotfix -e vscode  # Quick shorthand`

### 6. Update README.md documentation

**Update the `new` command section**:
- Add the new flags to the options list with descriptions
- Include examples showing the combined usage:
  - `git gtr new my-feature --editor cursor`
  - `git gtr new my-feature --ai claude`
  - `git gtr new my-feature -e cursor -a claude`

**Update the Quick Start section**:
- Consider adding an example showing the streamlined workflow with the new flags

## Implementation Flow

User runs: `git gtr new my-feature --editor cursor --ai claude`
  ↓
`cmd_create()` parses flags (--editor, --ai)
  ↓
Creates worktree
  ↓
Copies files (if not --no-copy)
  ↓
Runs postCreate hooks
  ↓
If --editor flag provided:
  - Load editor adapter (cursor)
  - Call `editor_open(worktree_path)`
  ↓
If --ai flag provided:
  - Load AI adapter (claude)
  - Call `ai_start(worktree_path)`
  ↓
Display conditional "Next steps" message

## Key Considerations

| Aspect | Decision | Rationale |
|--------|----------|-----------|
| **Flag naming** | `--editor`/`-e` and `--ai`/`-a` | Consistent with existing `editor` and `ai` commands; short forms for convenience |
| **Flag values** | Optional (use config default if omitted) | Allows `git gtr new feature -e` to use configured editor |
| **Error handling** | Non-fatal errors with warnings | If editor/AI fails to open, still show success message for worktree creation |
| **Execution order** | Editor before AI | Logical workflow: open editor first, then start AI tool |
| **Message updates** | Conditional display | Only show suggestions for actions not already performed |
| **Backwards compatibility** | Fully maintained | New flags are optional; existing workflows unchanged |
| **Philosophy alignment** | Flags are optional shortcuts | Aligns with "configuration over flags" - users can set defaults once, then use `-e` and `-a` as convenient shortcuts |

## Testing Checklist

- Test `git gtr new feature --editor cursor` opens editor after creation
- Test `git gtr new feature --ai claude` starts AI tool after creation
- Test `git gtr new feature -e vscode -a aider` combines both flags
- Test `git gtr new feature -e` uses default editor from config
- Test `git gtr new feature --editor cursor --ai claude` combines both flags with full names
- Test error handling when editor/AI tool not found
- Test that "Next steps" message adapts based on flags used (omits lines for actions already performed)
- Test that "Next steps" message shows all suggestions when no flags are used
- Verify tab completion works for new flags in bash, zsh, and fish
- Test on macOS, Linux, and Windows Git Bash if possible
- Verify help text displays new options correctly
- Test that worktree is created successfully even if editor/AI startup fails
- Test flag position independence (flags can appear before or after branch name)

---

Execution Information

Branch: main
Commit: 03ff84a

---

💡 Tips

Supported Commands (Inside Comments)

• Use @traycerai generate to iterate on the previous version of the implementation plan.

Supported Commands (Inside Description)

• Add @traycerai ignore anywhere in the ticket description to prevent this ticket from being processed.
• Add @traycerai branch:<branch-name> anywhere in the ticket description to specify the target branch for the implementation plan.

Community

• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.

[traycerai]

I have updated the Implementation Plan to reflect the recent changes in the ticket.

Previous Plan

Observations

The codebase follows a clean shell-based architecture with a "configuration over flags" philosophy. The new command (file:bin/gtr lines 113-294) currently displays "Next steps" suggestions after worktree creation. The editor and ai commands are already well-implemented with flag support (--editor and --ai). The flag parsing pattern is consistent across commands using case statements. Shell completions exist for bash, zsh, and fish. The project emphasizes cross-platform compatibility and user-friendly workflows.

Approach

The implementation will add --editor (short: -e) and --ai (short: -a) flags to the new command that automatically invoke the respective commands after worktree creation. This aligns with the existing flag patterns and provides a streamlined workflow. The flags will be optional and can be combined. The "Next steps" message will be conditionally displayed based on which flags were used. Completions will be updated to include the new flags, and help documentation will reflect the new options.

Implementation Steps

1. Update cmd_create function in file:bin/gtr

Add flag variables (after line 124):

• Add local auto_editor="" to store the editor name
• Add local auto_ai="" to store the AI tool name

Extend flag parsing (in the while loop starting at line 127):

• Add case for --editor|-e) that captures the next argument and stores in auto_editor, then shift 2
• Add case for --ai|-a) that captures the next argument and stores in auto_ai, then shift 2
• Position these new cases before the -*) unknown flag handler

Invoke editor after worktree creation (after line 285, before the "Next steps" message):

• Check if auto_editor is not empty
• If set, call the editor opening logic similar to cmd_editor:
  • Get editor from auto_editor or fall back to config using cfg_default
  • Load the editor adapter using load_editor_adapter
  • Call editor_open "$worktree_path"
  • Handle errors gracefully with log messages

Invoke AI tool after editor (after the editor invocation):

• Check if auto_ai is not empty
• If set, call the AI tool logic similar to cmd_ai:
  • Get AI tool from auto_ai or fall back to config using cfg_default
  • Validate that AI tool is not "none"
  • Load the AI adapter using load_ai_adapter
  • Call ai_start "$worktree_path"
  • Handle errors gracefully with log messages

Update "Next steps" message (lines 290-293):

• Make the message conditional based on which flags were used
• If --editor was used, omit the editor line from suggestions
• If --ai was used, omit the AI line from suggestions
• If both were used, only show the cd navigation suggestion
• Keep the message helpful for users who didn't use the flags

2. Update bash completion in file:completions/gtr.bash

Modify the new command completion (line 62):

• Add --editor and -e to the flag list
• Add --ai and -a to the flag list
• The updated line should include: --editor -e --ai -a along with existing flags

Add completion for flag values (after line 64):

• Add case for --editor|-e that completes with available editors: cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none
• Add case for --ai|-a that completes with available AI tools: aider claude codex continue copilot cursor gemini opencode none

3. Update zsh completion in file:completions/_git-gtr

Extend the new command arguments (lines 44-54):

• Add '--editor[Open in editor after creation]:editor:(cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none)'
• Add '-e[Open in editor after creation]:editor:(cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none)'
• Add '--ai[Start AI tool after creation]:tool:(aider claude codex continue copilot cursor gemini opencode none)'
• Add '-a[Start AI tool after creation]:tool:(aider claude codex continue copilot cursor gemini opencode none)'

4. Update fish completion in file:completions/gtr.fish

Add flag completions for the new command:

• Add completion for --editor and -e with editor options
• Add completion for --ai and -a with AI tool options
• Follow the existing fish completion syntax pattern

5. Update help documentation in file:bin/gtr

Update the new command description (around line 1164):

• Add --editor <name>, -e <name>: open in editor after creation to the options list
• Add --ai <name>, -a <name>: start AI tool after creation to the options list
• Position these after the existing flags but before --yes

Add workflow example (in the WORKFLOW EXAMPLES section around line 1270):

• Add example: git gtr new my-feature --editor cursor --ai claude # Create and start working immediately
• Add example: git gtr new hotfix -e vscode # Quick shorthand

6. Update README.md documentation

Update the new command section (around line 144):

• Add the new flags to the options list with descriptions
• Include examples showing the combined usage:
  • git gtr new my-feature --editor cursor
  • git gtr new my-feature --ai claude
  • git gtr new my-feature -e cursor -a claude

Update the Quick Start section (around line 42):

• Consider adding an example showing the streamlined workflow with the new flags

Implementation Flow

sequenceDiagram
    participant User
    participant cmd_create
    participant Worktree
    participant Editor
    participant AI

    User->>cmd_create: git gtr new my-feature --editor cursor --ai claude
    cmd_create->>cmd_create: Parse flags (--editor, --ai)
    cmd_create->>Worktree: Create worktree
    Worktree-->>cmd_create: worktree_path
    cmd_create->>cmd_create: Copy files (if not --no-copy)
    cmd_create->>cmd_create: Run postCreate hooks
    
    alt --editor flag provided
        cmd_create->>Editor: load_editor_adapter(cursor)
        cmd_create->>Editor: editor_open(worktree_path)
        Editor-->>cmd_create: Editor opened
    end
    
    alt --ai flag provided
        cmd_create->>AI: load_ai_adapter(claude)
        cmd_create->>AI: ai_start(worktree_path)
        AI-->>cmd_create: AI tool started
    end
    
    cmd_create->>User: Display conditional "Next steps" message

Loading

Key Considerations

Aspect	Decision	Rationale
Flag naming	--editor/-e and --ai/-a	Consistent with existing editor and ai commands; short forms for convenience
Flag values	Optional (use config default if omitted)	Allows git gtr new feature -e to use configured editor
Error handling	Non-fatal errors with warnings	If editor/AI fails to open, still show success message for worktree creation
Execution order	Editor before AI	Logical workflow: open editor first, then start AI tool
Message updates	Conditional display	Only show suggestions for actions not already performed
Backwards compatibility	Fully maintained	New flags are optional; existing workflows unchanged

Testing Checklist

• Test git gtr new feature --editor cursor opens editor after creation
• Test git gtr new feature --ai claude starts AI tool after creation
• Test git gtr new feature -e vscode -a aider combines both flags
• Test git gtr new feature -e uses default editor from config
• Test error handling when editor/AI tool not found
• Test that "Next steps" message adapts based on flags used
• Verify tab completion works for new flags in bash, zsh, and fish
• Test on macOS, Linux, and Windows Git Bash if possible
• Verify help text displays new options correctly

Import In IDE

🤖 Prompt for AI Agents

## Observations

The codebase follows a clean shell-based architecture with a "configuration over flags" philosophy. The `new` command (file:bin/gtr lines 113-294) currently displays "Next steps" suggestions after worktree creation. The `editor` and `ai` commands are already well-implemented with flag support (`--editor` and `--ai`). The flag parsing pattern is consistent across commands using case statements. Shell completions exist for bash, zsh, and fish. The project emphasizes cross-platform compatibility and user-friendly workflows.

## Approach

The implementation will add `--editor` (short: `-e`) and `--ai` (short: `-a`) flags to the `new` command that automatically invoke the respective commands after worktree creation. This aligns with the existing flag patterns and provides a streamlined workflow. The flags will be optional and can be combined. The "Next steps" message will be conditionally displayed based on which flags were used. Completions will be updated to include the new flags, and help documentation will reflect the new options.

## Implementation Steps

### 1. Update `cmd_create` function in file:bin/gtr

**Add flag variables** (after line 124):
- Add `local auto_editor=""` to store the editor name
- Add `local auto_ai=""` to store the AI tool name

**Extend flag parsing** (in the while loop starting at line 127):
- Add case for `--editor|-e)` that captures the next argument and stores in `auto_editor`, then `shift 2`
- Add case for `--ai|-a)` that captures the next argument and stores in `auto_ai`, then `shift 2`
- Position these new cases before the `-*)` unknown flag handler

**Invoke editor after worktree creation** (after line 285, before the "Next steps" message):
- Check if `auto_editor` is not empty
- If set, call the editor opening logic similar to `cmd_editor`:
  - Get editor from `auto_editor` or fall back to config using `cfg_default`
  - Load the editor adapter using `load_editor_adapter`
  - Call `editor_open "$worktree_path"`
  - Handle errors gracefully with log messages

**Invoke AI tool after editor** (after the editor invocation):
- Check if `auto_ai` is not empty
- If set, call the AI tool logic similar to `cmd_ai`:
  - Get AI tool from `auto_ai` or fall back to config using `cfg_default`
  - Validate that AI tool is not "none"
  - Load the AI adapter using `load_ai_adapter`
  - Call `ai_start "$worktree_path"`
  - Handle errors gracefully with log messages

**Update "Next steps" message** (lines 290-293):
- Make the message conditional based on which flags were used
- If `--editor` was used, omit the editor line from suggestions
- If `--ai` was used, omit the AI line from suggestions
- If both were used, only show the `cd` navigation suggestion
- Keep the message helpful for users who didn't use the flags

### 2. Update bash completion in file:completions/gtr.bash

**Modify the `new` command completion** (line 62):
- Add `--editor` and `-e` to the flag list
- Add `--ai` and `-a` to the flag list
- The updated line should include: `--editor -e --ai -a` along with existing flags

**Add completion for flag values** (after line 64):
- Add case for `--editor|-e` that completes with available editors: `cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none`
- Add case for `--ai|-a` that completes with available AI tools: `aider claude codex continue copilot cursor gemini opencode none`

### 3. Update zsh completion in file:completions/_git-gtr

**Extend the `new` command arguments** (lines 44-54):
- Add `'--editor[Open in editor after creation]:editor:(cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none)'`
- Add `'-e[Open in editor after creation]:editor:(cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none)'`
- Add `'--ai[Start AI tool after creation]:tool:(aider claude codex continue copilot cursor gemini opencode none)'`
- Add `'-a[Start AI tool after creation]:tool:(aider claude codex continue copilot cursor gemini opencode none)'`

### 4. Update fish completion in file:completions/gtr.fish

**Add flag completions for the `new` command**:
- Add completion for `--editor` and `-e` with editor options
- Add completion for `--ai` and `-a` with AI tool options
- Follow the existing fish completion syntax pattern

### 5. Update help documentation in file:bin/gtr

**Update the `new` command description** (around line 1164):
- Add `--editor <name>, -e <name>: open in editor after creation` to the options list
- Add `--ai <name>, -a <name>: start AI tool after creation` to the options list
- Position these after the existing flags but before `--yes`

**Add workflow example** (in the WORKFLOW EXAMPLES section around line 1270):
- Add example: `git gtr new my-feature --editor cursor --ai claude  # Create and start working immediately`
- Add example: `git gtr new hotfix -e vscode  # Quick shorthand`

### 6. Update README.md documentation

**Update the `new` command section** (around line 144):
- Add the new flags to the options list with descriptions
- Include examples showing the combined usage:
  - `git gtr new my-feature --editor cursor`
  - `git gtr new my-feature --ai claude`
  - `git gtr new my-feature -e cursor -a claude`

**Update the Quick Start section** (around line 42):
- Consider adding an example showing the streamlined workflow with the new flags

## Implementation Flow

```mermaid
sequenceDiagram
    participant User
    participant cmd_create
    participant Worktree
    participant Editor
    participant AI

    User->>cmd_create: git gtr new my-feature --editor cursor --ai claude
    cmd_create->>cmd_create: Parse flags (--editor, --ai)
    cmd_create->>Worktree: Create worktree
    Worktree-->>cmd_create: worktree_path
    cmd_create->>cmd_create: Copy files (if not --no-copy)
    cmd_create->>cmd_create: Run postCreate hooks
    
    alt --editor flag provided
        cmd_create->>Editor: load_editor_adapter(cursor)
        cmd_create->>Editor: editor_open(worktree_path)
        Editor-->>cmd_create: Editor opened
    end
    
    alt --ai flag provided
        cmd_create->>AI: load_ai_adapter(claude)
        cmd_create->>AI: ai_start(worktree_path)
        AI-->>cmd_create: AI tool started
    end
    
    cmd_create->>User: Display conditional "Next steps" message
```

## Key Considerations

| Aspect | Decision | Rationale |
|--------|----------|-----------|
| **Flag naming** | `--editor`/`-e` and `--ai`/`-a` | Consistent with existing `editor` and `ai` commands; short forms for convenience |
| **Flag values** | Optional (use config default if omitted) | Allows `git gtr new feature -e` to use configured editor |
| **Error handling** | Non-fatal errors with warnings | If editor/AI fails to open, still show success message for worktree creation |
| **Execution order** | Editor before AI | Logical workflow: open editor first, then start AI tool |
| **Message updates** | Conditional display | Only show suggestions for actions not already performed |
| **Backwards compatibility** | Fully maintained | New flags are optional; existing workflows unchanged |

## Testing Checklist

- Test `git gtr new feature --editor cursor` opens editor after creation
- Test `git gtr new feature --ai claude` starts AI tool after creation
- Test `git gtr new feature -e vscode -a aider` combines both flags
- Test `git gtr new feature -e` uses default editor from config
- Test error handling when editor/AI tool not found
- Test that "Next steps" message adapts based on flags used
- Verify tab completion works for new flags in bash, zsh, and fish
- Test on macOS, Linux, and Windows Git Bash if possible
- Verify help text displays new options correctly

---

Execution Information

Branch: main
Commit: 03ff84a

New Plan

Observations

The codebase is a well-structured Bash-based CLI tool for managing git worktrees with approximately 1,300 lines in the main script. The cmd_create function (lines 113-294) currently displays "Next steps" suggestions after worktree creation. The cmd_editor and cmd_ai functions are already implemented with flag support (--editor and --ai). The flag parsing pattern is consistent across commands using case statements. Shell completions exist for bash, zsh, and fish. The project emphasizes cross-platform compatibility and a "configuration over flags" philosophy.

Approach

The implementation will add --editor (short: -e) and --ai (short: -a) flags to the new command that automatically invoke the respective commands after worktree creation. This aligns with the existing flag patterns and provides a streamlined workflow. The flags will be optional and can be combined. The "Next steps" message will be conditionally displayed based on which flags were used. Completions will be updated to include the new flags, and help documentation will reflect the new options.

Implementation Steps

1. Update cmd_create function in bin/gtr

Add flag variables (after line 124):

• Add local auto_editor="" to store the editor name
• Add local auto_ai="" to store the AI tool name

Extend flag parsing (in the while loop starting at line 127):

• Add case for --editor|-e) that captures the next argument and stores in auto_editor, then shift 2
• Add case for --ai|-a) that captures the next argument and stores in auto_ai, then shift 2
• Position these new cases before the -*) unknown flag handler

Invoke editor after worktree creation (after line 285, before the "Next steps" message):

• Check if auto_editor is not empty
• If set, call the editor opening logic similar to cmd_editor:
  • Get editor from auto_editor or fall back to config using cfg_default
  • Load the editor adapter using load_editor_adapter
  • Call editor_open "$worktree_path"
  • Handle errors gracefully with log messages

Invoke AI tool after editor (after the editor invocation):

• Check if auto_ai is not empty
• If set, call the AI tool logic similar to cmd_ai:
  • Get AI tool from auto_ai or fall back to config using cfg_default
  • Validate that AI tool is not "none"
  • Load the AI adapter using load_ai_adapter
  • Call ai_start "$worktree_path"
  • Handle errors gracefully with log messages

Update "Next steps" message (lines 290-293):

• Make the message conditional based on which flags were used
• If --editor was used, omit the editor line from suggestions
• If --ai was used, omit the AI line from suggestions
• If both were used, only show the cd navigation suggestion
• Keep the message helpful for users who didn't use the flags

2. Update bash completion in completions/gtr.bash

Modify the new command completion (line 62):

• Add --editor and -e to the flag list
• Add --ai and -a to the flag list
• The updated line should include: --editor -e --ai -a along with existing flags

Add completion for flag values (after line 64):

• Add case for --editor|-e that completes with available editors: cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none
• Add case for --ai|-a that completes with available AI tools: aider claude codex continue copilot cursor gemini opencode none

3. Update zsh completion in completions/_git-gtr

Extend the new command arguments (lines 44-54):

• Add '--editor[Open in editor after creation]:editor:(cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none)'
• Add '-e[Open in editor after creation]:editor:(cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none)'
• Add '--ai[Start AI tool after creation]:tool:(aider claude codex continue copilot cursor gemini opencode none)'
• Add '-a[Start AI tool after creation]:tool:(aider claude codex continue copilot cursor gemini opencode none)'

4. Update fish completion in completions/gtr.fish

Add flag completions for the new command:

• Add completion for --editor and -e with editor options
• Add completion for --ai and -a with AI tool options
• Follow the existing fish completion syntax pattern

5. Update help documentation in bin/gtr

Update the new command description (around line 1164):

• Add --editor <name>, -e <name>: open in editor after creation to the options list
• Add --ai <name>, -a <name>: start AI tool after creation to the options list
• Position these after the existing flags but before --yes

Add workflow example (in the WORKFLOW EXAMPLES section around line 1270):

• Add example: git gtr new my-feature --editor cursor --ai claude # Create and start working immediately
• Add example: git gtr new hotfix -e vscode # Quick shorthand

6. Update README.md documentation

Update the new command section:

• Add the new flags to the options list with descriptions
• Include examples showing the combined usage:
  • git gtr new my-feature --editor cursor
  • git gtr new my-feature --ai claude
  • git gtr new my-feature -e cursor -a claude

Update the Quick Start section:

• Consider adding an example showing the streamlined workflow with the new flags

Implementation Flow

User runs: git gtr new my-feature --editor cursor --ai claude
↓
cmd_create() parses flags (--editor, --ai)
↓
Creates worktree
↓
Copies files (if not --no-copy)
↓
Runs postCreate hooks
↓
If --editor flag provided:

• Load editor adapter (cursor)
• Call editor_open(worktree_path)
  ↓
  If --ai flag provided:
• Load AI adapter (claude)
• Call ai_start(worktree_path)
  ↓
  Display conditional "Next steps" message

Key Considerations

Aspect	Decision	Rationale
Flag naming	--editor/-e and --ai/-a	Consistent with existing editor and ai commands; short forms for convenience
Flag values	Optional (use config default if omitted)	Allows git gtr new feature -e to use configured editor
Error handling	Non-fatal errors with warnings	If editor/AI fails to open, still show success message for worktree creation
Execution order	Editor before AI	Logical workflow: open editor first, then start AI tool
Message updates	Conditional display	Only show suggestions for actions not already performed
Backwards compatibility	Fully maintained	New flags are optional; existing workflows unchanged
Philosophy alignment	Flags are optional shortcuts	Aligns with "configuration over flags" - users can set defaults once, then use -e and -a as convenient shortcuts

Testing Checklist

• Test git gtr new feature --editor cursor opens editor after creation
• Test git gtr new feature --ai claude starts AI tool after creation
• Test git gtr new feature -e vscode -a aider combines both flags
• Test git gtr new feature -e uses default editor from config
• Test git gtr new feature --editor cursor --ai claude combines both flags with full names
• Test error handling when editor/AI tool not found
• Test that "Next steps" message adapts based on flags used (omits lines for actions already performed)
• Test that "Next steps" message shows all suggestions when no flags are used
• Verify tab completion works for new flags in bash, zsh, and fish
• Test on macOS, Linux, and Windows Git Bash if possible
• Verify help text displays new options correctly
• Test that worktree is created successfully even if editor/AI startup fails
• Test flag position independence (flags can appear before or after branch name)

Import In IDE

🤖 Prompt for AI Agents

## Observations

The codebase is a well-structured Bash-based CLI tool for managing git worktrees with approximately 1,300 lines in the main script. The `cmd_create` function (lines 113-294) currently displays "Next steps" suggestions after worktree creation. The `cmd_editor` and `cmd_ai` functions are already implemented with flag support (`--editor` and `--ai`). The flag parsing pattern is consistent across commands using case statements. Shell completions exist for bash, zsh, and fish. The project emphasizes cross-platform compatibility and a "configuration over flags" philosophy.

## Approach

The implementation will add `--editor` (short: `-e`) and `--ai` (short: `-a`) flags to the `new` command that automatically invoke the respective commands after worktree creation. This aligns with the existing flag patterns and provides a streamlined workflow. The flags will be optional and can be combined. The "Next steps" message will be conditionally displayed based on which flags were used. Completions will be updated to include the new flags, and help documentation will reflect the new options.

## Implementation Steps

### 1. Update `cmd_create` function in bin/gtr

**Add flag variables** (after line 124):
- Add `local auto_editor=""` to store the editor name
- Add `local auto_ai=""` to store the AI tool name

**Extend flag parsing** (in the while loop starting at line 127):
- Add case for `--editor|-e)` that captures the next argument and stores in `auto_editor`, then `shift 2`
- Add case for `--ai|-a)` that captures the next argument and stores in `auto_ai`, then `shift 2`
- Position these new cases before the `-*)` unknown flag handler

**Invoke editor after worktree creation** (after line 285, before the "Next steps" message):
- Check if `auto_editor` is not empty
- If set, call the editor opening logic similar to `cmd_editor`:
  - Get editor from `auto_editor` or fall back to config using `cfg_default`
  - Load the editor adapter using `load_editor_adapter`
  - Call `editor_open "$worktree_path"`
  - Handle errors gracefully with log messages

**Invoke AI tool after editor** (after the editor invocation):
- Check if `auto_ai` is not empty
- If set, call the AI tool logic similar to `cmd_ai`:
  - Get AI tool from `auto_ai` or fall back to config using `cfg_default`
  - Validate that AI tool is not "none"
  - Load the AI adapter using `load_ai_adapter`
  - Call `ai_start "$worktree_path"`
  - Handle errors gracefully with log messages

**Update "Next steps" message** (lines 290-293):
- Make the message conditional based on which flags were used
- If `--editor` was used, omit the editor line from suggestions
- If `--ai` was used, omit the AI line from suggestions
- If both were used, only show the `cd` navigation suggestion
- Keep the message helpful for users who didn't use the flags

### 2. Update bash completion in completions/gtr.bash

**Modify the `new` command completion** (line 62):
- Add `--editor` and `-e` to the flag list
- Add `--ai` and `-a` to the flag list
- The updated line should include: `--editor -e --ai -a` along with existing flags

**Add completion for flag values** (after line 64):
- Add case for `--editor|-e` that completes with available editors: `cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none`
- Add case for `--ai|-a` that completes with available AI tools: `aider claude codex continue copilot cursor gemini opencode none`

### 3. Update zsh completion in completions/_git-gtr

**Extend the `new` command arguments** (lines 44-54):
- Add `'--editor[Open in editor after creation]:editor:(cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none)'`
- Add `'-e[Open in editor after creation]:editor:(cursor vscode zed idea pycharm webstorm vim nvim emacs sublime nano atom none)'`
- Add `'--ai[Start AI tool after creation]:tool:(aider claude codex continue copilot cursor gemini opencode none)'`
- Add `'-a[Start AI tool after creation]:tool:(aider claude codex continue copilot cursor gemini opencode none)'`

### 4. Update fish completion in completions/gtr.fish

**Add flag completions for the `new` command**:
- Add completion for `--editor` and `-e` with editor options
- Add completion for `--ai` and `-a` with AI tool options
- Follow the existing fish completion syntax pattern

### 5. Update help documentation in bin/gtr

**Update the `new` command description** (around line 1164):
- Add `--editor <name>, -e <name>: open in editor after creation` to the options list
- Add `--ai <name>, -a <name>: start AI tool after creation` to the options list
- Position these after the existing flags but before `--yes`

**Add workflow example** (in the WORKFLOW EXAMPLES section around line 1270):
- Add example: `git gtr new my-feature --editor cursor --ai claude  # Create and start working immediately`
- Add example: `git gtr new hotfix -e vscode  # Quick shorthand`

### 6. Update README.md documentation

**Update the `new` command section**:
- Add the new flags to the options list with descriptions
- Include examples showing the combined usage:
  - `git gtr new my-feature --editor cursor`
  - `git gtr new my-feature --ai claude`
  - `git gtr new my-feature -e cursor -a claude`

**Update the Quick Start section**:
- Consider adding an example showing the streamlined workflow with the new flags

## Implementation Flow

User runs: `git gtr new my-feature --editor cursor --ai claude`
  ↓
`cmd_create()` parses flags (--editor, --ai)
  ↓
Creates worktree
  ↓
Copies files (if not --no-copy)
  ↓
Runs postCreate hooks
  ↓
If --editor flag provided:
  - Load editor adapter (cursor)
  - Call `editor_open(worktree_path)`
  ↓
If --ai flag provided:
  - Load AI adapter (claude)
  - Call `ai_start(worktree_path)`
  ↓
Display conditional "Next steps" message

## Key Considerations

| Aspect | Decision | Rationale |
|--------|----------|-----------|
| **Flag naming** | `--editor`/`-e` and `--ai`/`-a` | Consistent with existing `editor` and `ai` commands; short forms for convenience |
| **Flag values** | Optional (use config default if omitted) | Allows `git gtr new feature -e` to use configured editor |
| **Error handling** | Non-fatal errors with warnings | If editor/AI fails to open, still show success message for worktree creation |
| **Execution order** | Editor before AI | Logical workflow: open editor first, then start AI tool |
| **Message updates** | Conditional display | Only show suggestions for actions not already performed |
| **Backwards compatibility** | Fully maintained | New flags are optional; existing workflows unchanged |
| **Philosophy alignment** | Flags are optional shortcuts | Aligns with "configuration over flags" - users can set defaults once, then use `-e` and `-a` as convenient shortcuts |

## Testing Checklist

- Test `git gtr new feature --editor cursor` opens editor after creation
- Test `git gtr new feature --ai claude` starts AI tool after creation
- Test `git gtr new feature -e vscode -a aider` combines both flags
- Test `git gtr new feature -e` uses default editor from config
- Test `git gtr new feature --editor cursor --ai claude` combines both flags with full names
- Test error handling when editor/AI tool not found
- Test that "Next steps" message adapts based on flags used (omits lines for actions already performed)
- Test that "Next steps" message shows all suggestions when no flags are used
- Verify tab completion works for new flags in bash, zsh, and fish
- Test on macOS, Linux, and Windows Git Bash if possible
- Verify help text displays new options correctly
- Test that worktree is created successfully even if editor/AI startup fails
- Test flag position independence (flags can appear before or after branch name)

---

Execution Information

Branch: main
Commit: 03ff84a