Git Stream Command Reference

📚 For detailed documentation of each command with all options and examples, see the docs/commands/ directory.

Command Structure

All Git Stream commands follow the pattern: gstr [command] [subcommand] [options] [arguments]

Interactive Experience

Git Stream provides an intelligent, interactive experience where all parameters are optional. When information is missing, commands provide contextual prompts with smart defaults:

Start Commands: Prompt for missing names/keys with validation
Finish Commands: Show selection menus of active items
Context-Aware: Display relevant options based on repository state
Smart Defaults: Sensible fallbacks and guided workflows
Flexible Usage: Works for both interactive users and automation/scripting

Interactive Patterns

# All parameters optional - commands guide you through
gstr feature start          # → Prompts for name, then epic selection
gstr epic start            # → Prompts for epic key and description
gstr release start         # → Prompts for version, then feature selection
gstr feature finish        # → Shows menu of active features to select
gstr release finish        # → Shows menu of active releases to select

Core Commands

Initialization and Configuration

`gstr init`

Initialize Git Stream in the current repository.

Usage: gstr init

Interactive Flow:

Validates repository structure (requires main/develop branches)
Detects remote origin (if any)
If no origin detected, prompts user to add one or continue locally
If origin provided, auto-detects provider (GitHub/BitBucket) from URL
If remote mode, prompts for merge strategy (PR or direct)
Sets up appropriate workflow mode and strategy

Actions:

Creates .git/gitstream/ repository configuration directory (config.json)
Sets up initial configuration with detected/selected provider
Installs/updates required git hooks in existing .git/hooks/
Configures workflow mode and merge strategy based on choices
Creates initial deployment tags (testing→develop, production→main)

Workflow Modes and Strategies:

Remote Mode with PR Strategy: Uses pull requests via GitHub/BitBucket API
Remote Mode with Direct Strategy: Push branches, merge locally, push results (no PRs)
Local Mode: Direct branch merges, no remote (completely offline)

Prerequisites:

Must be run in a git repository
Repository must have main and develop branches

Example Interactive Flow:

$ gstr init

Analyzing repository...
✓ Found main and develop branches
✗ No remote origin detected

Would you like to:
1. Add a remote origin (enables PR workflow)
2. Continue with local workflow (direct merges)
3. Exit and configure manually

Choice [1]: 1
Enter remote origin URL: https://github.com/proudnerds/my-repo.git

✓ Remote origin added: origin
✓ Detected provider: GitHub
? Do you want to use pull requests for merging? (yes/no): yes
✓ Configured for remote mode with PR strategy
✓ Git Stream initialized successfully

`gstr config [key] [value]`

Manage Git Stream configuration settings.

Usage:

gstr config - Show all configuration
gstr config <key> - Show specific configuration value
gstr config <key> <value> - Set configuration value
gstr config --global <key> <value> - Set global configuration value
gstr config test-github - Test GitHub API connectivity + token
gstr config test-bitbucket - Test BitBucket API connectivity + credentials
gstr config import --file <path> - Import configuration file
gstr config migrate --from-version <version> - Migrate legacy configuration
gstr config --reset <key> / --reset-all - Reset repository configuration
gstr config --global --reset <key> / --global --reset-all - Reset global configuration

Configuration Keys (canonical schema):

credentials.github.token - GitHub personal access token (global)
credentials.bitbucket.username - BitBucket username (global)
credentials.bitbucket.password - BitBucket app password (global)
defaults.provider - Default git provider (global)
branches.prefixes.feature - Feature branch prefix (repository)
branches.prefixes.release - Release branch prefix (repository)
branches.prefixes.hotfix - Hotfix branch prefix (repository)
workflow.auto_cleanup - Auto-cleanup merged branches (repository)
workflow.require_pr_review - Require PR review before merge (repository/global default)
workflow.auto_delete_branches - Auto-delete merged branches (repository/global default)
workflow.confirm_destructive - Confirm destructive operations (repository/global default)
hooks.pre_commit|pre_push|post_merge - Enable/disable hook installation (repository/global default)

Connectivity Tests:

gstr config test-github:
- Validates token presence & scopes (repo, pull_requests, contents)
- Performs authenticated request to API base (default https://api.github.com)
- Returns exit code 0 on success; 4 on network/API failure; 2 on configuration error
gstr config test-bitbucket:
- Validates username & app password presence
- Performs authenticated request to BitBucket API base (default https://api.bitbucket.org/2.0)
- Same exit code semantics as above

Exit Codes (config commands):

0 success
2 configuration error (missing / invalid key, invalid value)
4 network/API error (for test-* operations)

`gstr status`

Show current repository status and active branches.

Usage: gstr status

Output:

Current branch and its type
Active feature branches
Active release branches
Active hotfix branches
Pending PRs
Repository state validation

Epic Workflow

Epics group related features under a single deliverable unit, enabling coherent feature development and release management.

`gstr epic start [epic-key]`

Create a new epic branch from main (stable base).

Usage:

gstr epic start - Interactive: prompts for epic key and description
gstr epic start <epic-key> - Direct: creates epic with specified key

Interactive Flow:

$ gstr epic start
Enter epic key: AUTH-123
Enter epic description (optional): User Authentication System
✓ Created epic/AUTH-123

Actions:

Validates epic key doesn't already exist
Creates epic branch: epic/<key> from main (stable base)
Updates main branch from remote (if remote origin configured)
Switches to the epic branch
Records epic state and metadata

Branch Structure: epic/[EPIC-KEY] (e.g., epic/AUTH-123)

`gstr epic finish [epic-key]`

Complete an epic and merge all features to develop.

Usage:

gstr epic finish - Interactive: shows menu of active epics
gstr epic finish <epic-key> - Direct: finishes specified epic

Interactive Flow:

$ gstr epic finish
Select epic to finish:
  1. AUTH-123: User Authentication System (2/2 features complete)
  2. PROFILE-789: User Profile Management (1/3 features active)
Select epic (1-2): 1
✓ Completed epic AUTH-123

Actions:

Validates all epic features are completed
Merges epic branch to develop (creates PR if using PR strategy)
Cleans up epic and feature branches

Prerequisites: All features within the epic must be finished first

`gstr epic list`

List all active epics with feature progress.

Usage: gstr epic list

Output:

Active Epics:
┌─────────────┬────────────────────┬──────────┬─────────────────────────────┬─────────────┐
│ Epic        │ Branch             │ Status   │ Features                    │ Progress    │
├─────────────┼────────────────────┼──────────┼─────────────────────────────┼─────────────┤
│ AUTH-123    │ epic/AUTH-123      │ Active   │ login-form✓, oauth-flow✓   │ 2/3 (67%)   │
│             │                    │          │ password-reset○             │             │
└─────────────┴────────────────────┴──────────┴─────────────────────────────┴─────────────┘

Legend: ✓ = Completed, ○ = Active, ✗ = Blocked

Feature Workflow

Features can be created as standalone branches or within epic contexts for grouped development.

`gstr feature start [name] [epic-key]`

Create a new feature branch from main (stable base) or within an epic.

Usage:

gstr feature start - Interactive: prompts for name, then epic selection
gstr feature start <name> - Interactive epic selection if epics exist
gstr feature start <name> <epic-key> - Direct: create feature in specific epic
gstr feature start <name> --standalone - Direct: create standalone feature

`gstr feature continue`

Switch to an existing feature branch to continue work.

Usage: gstr feature continue

Interactive Flow:

$ gstr feature continue

┌─────────────────────────────────────────────────────────────┐
│                    Continue Feature Work                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  📋 Standalone Features                                     │
│    ○ user-profile                      [Jan 15] Active     │
│                                                             │
│  📦 Epic: AUTH-123 (User Authentication)                   │
│    ○ login-form                        [Jan 14] Active     │
│    ● password-reset                    [Jan 16] Current    │
│                                                             │
│  Navigation: ↑↓ to move, SPACE to select, ENTER to confirm │
└─────────────────────────────────────────────────────────────┘

Actions:

Shows enhanced menu with epic hierarchy and current branch highlighting
Displays feature status and creation dates
Switches to selected feature branch
Shows feature information and next steps
Validates working tree before switching

Interactive Epic Selection:

$ gstr feature start user-profile

Active epics detected. Where should this feature be created?
  1. 📁 epic/AUTH-123: User Authentication System (1 active feature)
  2. 📁 epic/PROFILE-789: User Profile Management (no features)
  3. 🌿 main (standalone feature)
Select target (1-3): 2
✓ Created epic/PROFILE-789/user-profile

Actions:

Prompts for feature name if not provided
Shows epic selection if active epics exist
Creates appropriate branch:
- Epic feature: epic/[EPIC-KEY]/[FEATURE-NAME]
- Standalone: feature/[FEATURE-NAME] (from main)
Updates base branch from remote (epic branch or main)
Switches to the new feature branch
Records feature state with epic relationship

Branch Types:

Epic Feature: epic/AUTH-123/login-form (from epic, merges to epic branch)
Standalone Feature: feature/user-settings (from main, merges to develop)

`gstr feature finish [name]`

Complete a feature and merge to its target branch.

Usage:

gstr feature finish - Interactive: shows menu of active features
gstr feature finish <name> - Direct: finishes specified feature

Interactive Selection:

$ gstr feature finish
Select feature to finish:
  1. user-profile (epic/PROFILE-789/user-profile) - in PROFILE-789
  2. login-form (epic/AUTH-123/login-form) - in AUTH-123
  3. database-fix (feature/database-fix) - standalone
Select feature (1-3): 1
✓ Merged epic/PROFILE-789/user-profile → epic/PROFILE-789

Actions:

Shows active features if name not provided
Validates feature branch exists and is current
Determines merge target:
- Epic features: Merge to parent epic branch
- Standalone features: Merge to develop branch
PR Strategy: Creates PR to target branch via API
Direct Strategy or Local Mode: Direct merge to target branch
Cleans up feature branch

Merge Strategies:

PR Strategy (Remote Mode): Creates pull requests for code review
Direct Strategy (Remote Mode): Push, merge locally, push results
Local Mode: Direct merges with no remote operations

`gstr feature list`

List all active features with epic relationships.

Usage: gstr feature list

Output:

Active Features:
┌──────────────┬─────────────────────────────────┬──────────┬─────────────┬──────────┐
│ Feature      │ Branch                          │ Context  │ Created     │ PR       │
├──────────────┼─────────────────────────────────┼──────────┼─────────────┼──────────┤
│ user-profile │ epic/PROFILE-789/user-profile   │ PROFILE-789 │ Jan 15   │ N/A      │
│ login-form   │ epic/AUTH-123/login-form        │ AUTH-123 │ Jan 14      │ #42      │
│ database-fix │ feature/database-fix            │ standalone │ Jan 13    │ N/A      │
└──────────────┴─────────────────────────────────┴──────────┴─────────────┴──────────┘

Release Workflow

Releases support both epic-centric and mixed feature selection, enabling coherent delivery of complete feature sets.

`gstr release start [version]`

Create a new release branch with interactive epic and feature selection.

Usage:

gstr release start - Interactive: prompts for version, then epic/feature selection
gstr release start <version> - Interactive feature selection with specified version

`gstr release continue`

Switch to an existing release branch to continue work.

Usage: gstr release continue

Interactive Flow:

$ gstr release continue

┌─────────────────────────────────────────────────────────────┐
│                    Continue Release Work                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│    ○ v1.2.0 (2 epics, 3 features) [Jan 15] Active         │
│    ● v1.3.0 (1 epic, 1 feature) [Jan 16] Current          │
│    ○ v2.0.0 (0 epics, 0 features) [Jan 17] Active         │
│                                                             │
│  Navigation: ↑↓ to move, SPACE to select, ENTER to confirm │
└─────────────────────────────────────────────────────────────┘

Actions:

Shows enhanced menu with release information and current branch highlighting
Displays epic and feature counts for each release
Switches to selected release branch
Shows release composition and next steps
Validates working tree before switching

Interactive Flow:

$ gstr release start
Enter release version: 2025-Q1
Enter release description (optional): Q1 2025 Authentication Release

Available items for release 2025-Q1:

Completed Epics:
  ✓ AUTH-123: User Authentication System (3 features)
    └── login-form, oauth-flow, password-reset
  
  ✓ SEARCH-890: Search & Discovery (2 features)
    └── elastic-search, advanced-filters

Standalone Features:
  ✓ database-migration: Performance schema updates
  ✓ security-patch: Fix XSS vulnerability in forms
  ✓ api-versioning: Add v2 API endpoints

Select items for this release:
[x] AUTH-123 (User Authentication System)
[ ] SEARCH-890 (Search & Discovery)
[x] database-migration
[x] security-patch
[ ] api-versioning

✓ Release will include:
  - Epic AUTH-123: login-form, oauth-flow, password-reset
  - Feature: database-migration
  - Feature: security-patch

Actions:

Prompts for release version if not provided
Shows completed epics and standalone features
Allows mixed selection of epics and individual features
Creates release branch: release/<version> from main
Merges selected epics and features into release branch
Records release composition and epic relationships
Switches to release branch

Selection Rules:

Complete epics only: Partial epics cannot be selected
All-or-nothing: Selecting an epic includes all its features
Mixed selection: Both epics and standalone features supported
Clear grouping: UI distinguishes between epics and standalone features

Branch Structure: release/[VERSION] (e.g., release/v1.3.0)

`gstr release finish [version]`

Complete a release and merge to main.

Usage:

gstr release finish - Interactive: shows menu of active releases
gstr release finish <version> - Direct: finishes specified release

Interactive Selection:

$ gstr release finish
Select release to finish:
  1. 2025-Q1: Q1 2025 Authentication Release (active development)
  2. hotfix-1: Critical security hotfix (PR #67 - ready to merge)
Select release (1-2): 1
✓ Finishing release 2025-Q1...

Actions:

Shows active releases if version not provided
Validates release branch exists and is current
PR Strategy: Creates PR to main branch with epic/feature summary
Direct Strategy or Local Mode: Direct merge to main with release tag creation
Also merges back to develop to keep branches synchronized
Cleans up release branch after successful merge
Creates release tag with version and included features

Release Description: Automatically generated with epic and feature details

`gstr release add [version]`

Add additional features or epics to an existing release branch.

Usage:

gstr release add - Interactive: shows menu of active releases
gstr release add <version> - Add items to specified release

See: Release Add Documentation for detailed usage.

`gstr release remove [version]`

Remove features or epics from an existing release branch using safe revert operations.

Usage:

gstr release remove - Interactive: shows menu of active releases
gstr release remove <version> - Remove items from specified release

Key Features:

Safe git revert strategy (preserves history)
Automatic rollback on failure
Branch preservation for removed items
Dependency and conflict detection
Deployment tag updates

Common Options:

--features / -f - Specific features to remove
--epics / -e - Specific epics to remove
--dry-run - Preview changes without reverting
--no-sync - Skip auto-sync before removal

Example:

# Interactive removal
gstr release remove v1.2.0

# Remove specific features
gstr release remove v1.2.0 --features=user-profile --features=api-auth

# Remove entire epic
gstr release remove v1.2.0 --epics=AUTH-123

# Preview without reverting
gstr release remove --dry-run

See: Release Remove Documentation for detailed usage and examples.

`gstr release list`

List all active and recent releases with epic/feature composition.

Usage: gstr release list

Output:

Active Releases:
┌─────────┬────────────────────┬──────────┬─────────────────────────────┬─────────────┬──────────┐
│ Version │ Branch             │ Status   │ Content                     │ Created     │ PR       │
├─────────┼────────────────────┼──────────┼─────────────────────────────┼─────────────┼──────────┤
│ 2025-Q1 │ release/2025-Q1    │ Active   │ Epic AUTH-123, 2 features   │ Jan 15      │ N/A      │
│ hotfix-1│ release/hotfix-1   │ PR Ready │ 1 hotfix                    │ Jan 14      │ #67      │
└─────────┴────────────────────┴──────────┴─────────────────────────────┴─────────────┴──────────┘

Recently Completed Releases:
┌─────────┬─────────────────────────────┬─────────────┬──────────┐
│ Version │ Content                     │ Completed   │ PR       │
├─────────┼─────────────────────────────┼─────────────┼──────────┤
│ sprint-5│ Epic SEARCH-456, 3 features │ Jan 12      │ #65      │
│ R1      │ Epic MOBILE-789             │ Jan 08      │ N/A      │
└─────────┴─────────────────────────────┴─────────────┴──────────┘

Hotfix Workflow

`gstr hotfix start [name]`

Create a hotfix branch from main for critical production fixes.

Usage:

gstr hotfix start - Interactive: prompts for hotfix name and description
gstr hotfix start <name> - Direct: creates hotfix with specified name

Interactive Flow:

$ gstr hotfix start
Enter hotfix identifier: security-patch-001
Enter hotfix description (optional): Fix SQL injection vulnerability
✓ Created hotfix/security-patch-001 from main

Actions:

Prompts for hotfix name if not provided
Validates current state and working tree
Updates main branch from remote (if remote origin configured)
Creates hotfix branch: hotfix/<name> from main
Switches to hotfix branch
Records hotfix state and metadata

Branch Structure: hotfix/[IDENTIFIER] (e.g., hotfix/security-patch-001)

`gstr hotfix finish [name]`

Complete hotfix and merge to both main and develop.

Usage:

gstr hotfix finish - Interactive: shows menu of active hotfixes
gstr hotfix finish <name> - Direct: finishes specified hotfix

Interactive Selection:

$ gstr hotfix finish
Select hotfix to finish:
  1. security-patch-001: Fix SQL injection vulnerability
  2. payment-bug-fix: Resolve PayPal integration issue
Select hotfix (1-2): 1
✓ Merged hotfix/security-patch-001 → main and develop

Actions:

Shows active hotfixes if name not provided
Validates hotfix branch exists and is current
PR Strategy: Creates PRs to both main and develop branches
Direct Strategy or Local Mode: Direct merge to main, then merge to develop
Creates hotfix tag on main branch
Cleans up hotfix branch after successful merge

Dual-Branch Strategy: Hotfixes merge to both main (production) and develop (ongoing development)

Utility Commands

`gstr commit [options]`

Safe wrapper around git commit with enforced workflow tagging and direct git commit interception.

Usage: gstr commit [git-commit-options] [--] <paths?>

Direct Git Commit Blocking:

Direct invocation of git commit (outside Git Stream) is prevented via installed git hooks
Users are guided to use gstr commit ...
Attempts to bypass (except during internal Git Stream-controlled operations) result in hook rejection with remediation hint

Automatic Message Tagging: All commit messages are rewritten to prefix a workflow key derived from branch context:

feature/ => [FEAT:<slug>] | original message
epic/ => [EPIC:<epic-key>] | original message
epic// => [FEAT:<epic-key>/<feature-name>] | original message
hotfix/ => [HOTFIX:<slug>] | original message
release/ => [REL:<version>] | original message
main => [MAIN] | original message (only when Git Stream performs merges or maintenance)
develop => [DEV] | original message (same restriction as main)
Other (unexpected) => [GENERIC] | original message

Slug extraction rules:

For feature/hotfix: strip prefix after first /
For epic branches: use epic key after epic/
For epic features: use full path after epic/ (e.g., AUTH-123/login-form)
For release: full suffix after release/ used verbatim

Safety Enhancements:

Blocks commits on protected branches (main, develop, release/, hotfix/) unless part of sanctioned workflow step (e.g. finishing release/hotfix)
Validates working tree & staging state (aborts on unresolved conflicts unless --no-verify)
Normalizes author / committer info if branding overrides apply
Updates internal state tracker post-commit (records tag + original message payload)

Pass-through Git Options (forwarded and still subject to tagging):

-m, -a, -am, -n/--no-verify, --signoff, -S, --gpg-sign, --allow-empty, --amend (validated), --no-edit (Unsupported or unsafe options produce exit code 2)

Message Handling Logic:

User provides -m "Message" or -am "Message"
Git Stream derives KEY
Final executed underlying command: git commit -am "[KEY] | Message" (or equivalent option set)
Amend operations preserve existing KEY unless branch context changed (then Git Stream re-tags)

Additional Internal Flags (reserved):

--allow-protected (not enabled)
--skip-state (troubleshooting only)

Exit Codes:

0 success
2 configuration / safety violation (including forbidden direct invoke attempt routed through wrapper)
3 repository validation failure (conflicts, dirty index rules)
5 user cancelled (confirmation declined)

Examples:

On feature/user-auth: gstr commit -am "Add validation" => executes git commit -am "[FEAT:user-auth] | Add validation"
On hotfix/critical-patch: gstr commit -m "Patch overflow" => [HOTFIX:critical-patch] | Patch overflow
On release/2024-Q1: gstr commit -m "Adjust changelog" => [REL:2024-Q1] | Adjust changelog
Amend (no message): gstr commit --amend --no-edit (retains existing prefix)

`gstr sync`

Check for merged PRs and execute post-merge actions.

Usage: gstr sync

Actions:

Polls GitHub/BitBucket for merged PRs
Identifies merged features/releases/hotfixes
Executes post-merge actions:
- Creates release tags on main
- Cleans up merged branches (if configured)
- Updates develop with hotfix changes
- Reports completed actions

Example Output:

Checking for merged PRs...
✓ Feature 'user-authentication' merged to develop
✓ Release '2024-Q1' merged to main - created tag 2024-Q1
✓ Cleaned up 2 merged feature branches

`gstr clean`

Clean up merged branches and outdated state.

Usage: gstr clean [options]

Options:

--dry-run - Show what would be cleaned without doing it
--force - Clean without confirmation prompts
--all - Clean all merged branches (not just features)

Actions:

Identifies merged and safe-to-delete branches
Removes local branches that have been merged
Cleans up stale PR tracking data
Removes outdated state information

Global Options

All commands support these global options:

--verbose, -v - Increase output verbosity
--quiet, -q - Suppress non-essential output
--dry-run - Show what would happen without executing
--help, -h - Show command help
--version - Show Git Stream version

Exit Codes

0 - Success
1 - General error
2 - Configuration error
3 - Repository validation error
4 - Network/API error
5 - User cancelled operation

Examples

Complete Feature Workflow

# Start new feature
gstr feature start user-login

# Work on feature (multiple commits)
gstr commit -m "Add login form"
gstr commit -m "Add validation"
gstr commit -m "Add tests"

# Finish feature (creates PR)
gstr feature finish user-login

# Check status
gstr status

Release Creation Workflow

# Create release with interactive feature selection
gstr release start 2024-Q2

# Review and test release branch
gstr status

# Complete release (creates PR to main)
gstr release finish 2024-Q2

# Sync to handle merged PR and create tags
gstr sync

Hotfix Workflow

# Create hotfix
gstr hotfix start critical-bug-fix

# Fix the issue
gstr commit -m "Fix critical security issue"

# Finish hotfix (creates PRs to main and develop)
gstr hotfix finish critical-bug-fix

# Sync to handle merges and tagging
gstr sync

### Epic Development Workflow
```bash
# Start new epic (interactive)
gstr epic start
# → Enter epic key: AUTH-123
# → Enter description: User Authentication System
# ✓ Created epic/AUTH-123

# Add features to epic (interactive selection)
gstr feature start
# → Enter feature name: login-form
# → Select target: epic/AUTH-123
# ✓ Created epic/AUTH-123/login-form

gstr feature start
# → Enter feature name: oauth-integration  
# → Select target: epic/AUTH-123
# ✓ Created epic/AUTH-123/oauth-integration

# Work on features (tagged commits)
gstr commit -m "Add login form component"
# → Executes: git commit -m "[FEAT:AUTH-123/login-form] | Add login form component"

# Switch to other feature
git checkout epic/AUTH-123/oauth-integration
gstr commit -m "Implement OAuth flow"
# → Executes: git commit -m "[FEAT:AUTH-123/oauth-integration] | Implement OAuth flow"

# Finish features (interactive if no name provided)
gstr feature finish login-form
# ✓ Merged epic/AUTH-123/login-form → epic/AUTH-123

gstr feature finish
# → Select feature: oauth-integration
# ✓ Merged epic/AUTH-123/oauth-integration → epic/AUTH-123

# Complete epic (interactive selection)
gstr epic finish
# → Select epic: AUTH-123 (2/2 features complete)
# ✓ Merged epic/AUTH-123 → develop, cleaned up branches

Mixed Feature Development

# Create both epic and standalone features
gstr epic start CHECKOUT-456
gstr feature start payment-gateway CHECKOUT-456  # Epic feature
gstr feature start database-migration --standalone  # Standalone feature

# Interactive feature finishing
gstr feature finish
# → Select from: payment-gateway (in CHECKOUT-456), database-migration (standalone)

Epic-Aware Release Creation

# Create release with epic-aware selection (interactive)
gstr release start
# → Enter version: 2025-Q1
# → Epic AUTH-123: ✓ Selected (all features)
# → Standalone database-migration: ✓ Selected
# → Epic CHECKOUT-456: ✗ Not selected (incomplete)
# ✓ Created release/2025-Q1 with AUTH-123 epic + database-migration

# Complete release (interactive selection)
gstr release finish
# → Select release: 2025-Q1
# ✓ Created PR to main with epic/feature summary

Interactive Command Examples

# All commands work without parameters
gstr epic start          # → Prompts for epic key
gstr feature start       # → Prompts for name, then epic selection
gstr feature finish      # → Shows active features menu
gstr release start       # → Prompts for version, then epic/feature selection
gstr release finish      # → Shows active releases menu
gstr hotfix start        # → Prompts for identifier
gstr hotfix finish       # → Shows active hotfixes menu

# Override with specific parameters for scripting
gstr feature start user-settings --standalone
gstr release finish 2024-Q1
gstr epic finish AUTH-123

FilesExpand file tree

commands.md

Latest commit

History

commands.md

File metadata and controls

Git Stream Command Reference

Command Structure

Interactive Experience

Interactive Patterns

Core Commands

Initialization and Configuration

gstr init

gstr config [key] [value]

gstr status

Epic Workflow

gstr epic start [epic-key]

gstr epic finish [epic-key]

gstr epic list

Feature Workflow

gstr feature start [name] [epic-key]

gstr feature continue

gstr feature finish [name]

gstr feature list

Release Workflow

gstr release start [version]

gstr release continue

gstr release finish [version]

gstr release add [version]

gstr release remove [version]

gstr release list

Hotfix Workflow

gstr hotfix start [name]

gstr hotfix finish [name]

Utility Commands

gstr commit [options]

gstr sync

gstr clean

Global Options

Exit Codes

Examples

Complete Feature Workflow

Release Creation Workflow

Hotfix Workflow

Mixed Feature Development

Epic-Aware Release Creation

Interactive Command Examples

`gstr init`

`gstr config [key] [value]`

`gstr status`

`gstr epic start [epic-key]`

`gstr epic finish [epic-key]`

`gstr epic list`

`gstr feature start [name] [epic-key]`

`gstr feature continue`

`gstr feature finish [name]`

`gstr feature list`

`gstr release start [version]`

`gstr release continue`

`gstr release finish [version]`

`gstr release add [version]`

`gstr release remove [version]`

`gstr release list`

`gstr hotfix start [name]`

`gstr hotfix finish [name]`

`gstr commit [options]`

`gstr sync`

`gstr clean`