/gt-create-stack

Context

• Current git status: !git status
• Current git diff (all changes): !git diff HEAD
• Current branch: !git branch --show-current
• Current stack structure: !gt log short 2>/dev/null || echo "Not in Graphite repo or no existing stack"

Your Task

Based on the current changes and context, create a Graphite stack following these steps:

Step 1: Analyze Changes

Review the git diff and determine:

1. What feature/work is being implemented
2. How to logically split it into independent, reviewable pieces
3. Estimate LOC for each piece (target: under 200 LOC per PR)

Step 2: Choose Stacking Framework

Select the appropriate framework:

• Functional Components - If changes span layers (database, backend, frontend)
• Iterative Improvement - If building MVP then enhancements
• Refactor/Change - If refactoring is needed before the actual change
• Version Bumps/Generated - If upgrading dependencies or regenerating code
• Riskiness - If some changes are safer than others

Step 3: Plan the Stack

Explain to the user:

I'll create a stack of X PRs:
1. [Name] (~Y LOC) - [What it does]
2. [Name] (~Z LOC) - [What it does]
...

This uses the [Framework Name] pattern because [reason].

Step 4: Create the Stack

Execute the following workflow:

1. Ensure starting from correct base:

   gt log  # Show current position
   # If needed: gt bottom (to start from trunk) or gt checkout base-branch
   

2. Create first branch with initial changes:

   # Stage appropriate files for first piece
   git add <files-for-first-piece>
   gt create -m "First piece: descriptive title"
   

3. Continue building upstack immediately:

   # Stage files for second piece
   git add <files-for-second-piece>
   gt create -m "Second piece: descriptive title"
   
   # Repeat for each piece
   

4. Show final stack structure:

   gt log
   

5. Optionally submit (ask user first):

   Would you like me to submit this stack now with `gt submit --stack`?
   

Important Guidelines

• Don't wait between branches - Create all branches in sequence
• Use descriptive commit messages - Each should clearly state what the PR does
• Keep branches focused - Each branch should have one clear purpose
• Estimate LOC accurately - If a branch will exceed 200 LOC, split it further
• Build bottom-up - Start with foundation (database, utilities) and build upstack

Common Patterns

Full-stack feature:

gt create -am "Add database migration for [feature]"
gt create -am "Add backend service for [feature]"
gt create -am "Add API endpoints for [feature]"
gt create -am "Add UI components for [feature]"
gt create -am "Add integration tests for [feature]"

Bug fix with refactor:

gt create -am "Refactor: extract [code] for clarity"
gt create -am "Fix: [specific bug]"
gt create -am "Test: add regression test for [bug]"

Dependency upgrade:

gt create -am "Upgrade [package] to v[X]"
gt create -am "Migrate to new [package] API"
gt create -am "Optimize using new [package] features"

After Creating Stack

Report to user:

✅ Created stack of X branches:
- branch-1: [title] (~Y LOC)
- branch-2: [title] (~Z LOC)
...

Stack structure:
[show gt log output]

Next steps:
- Review the changes in each branch
- Run `gt submit --stack` to create PRs when ready
- Or continue building upstack with `gt create -am "next piece"`