@atlashub/smartstack-cli 1.13.2 → 1.14.0

package/templates/skills/gitflow/steps/step-pr.md

@@ -0,0 +1,235 @@
+---
+name: step-pr
+description: Create pull request with auto-detection
+next_step: null
+---
+
+# Step: PR - Create Pull Request
+
+## YOUR TASK:
+
+Create a pull request with proper target, title, and description based on branch type.
+
+**ULTRA THINK about PR requirements.**
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Detect Git Provider
+
+```bash
+REMOTE_URL=$(git remote get-url origin)
+
+if [[ "$REMOTE_URL" == *"github.com"* ]]; then
+  GIT_PROVIDER="github"
+elif [[ "$REMOTE_URL" == *"dev.azure.com"* ]] || [[ "$REMOTE_URL" == *"visualstudio.com"* ]]; then
+  GIT_PROVIDER="azuredevops"
+  # Extract Azure DevOps details
+  [[ "$REMOTE_URL" =~ dev\.azure\.com/([^/]+)/([^/]+)/_git/([^/]+) ]] && {
+    AZURE_ORG="${BASH_REMATCH[1]}"
+    AZURE_PROJECT="${BASH_REMATCH[2]}"
+    AZURE_REPO="${BASH_REMATCH[3]}"
+  }
+else
+  GIT_PROVIDER="unknown"
+fi
+```
+
+### 2. Determine PR Target
+
+```bash
+CURRENT=$(git rev-parse --abbrev-ref HEAD)
+
+case "$CURRENT" in
+  feature/*) TARGET_BRANCH="develop" ;;
+  release/*) TARGET_BRANCH="main" ;;
+  hotfix/*)  TARGET_BRANCH="main" ;;
+  *)         TARGET_BRANCH="develop" ;;
+esac
+```
+
+### 3. Check Prerequisites
+
+```bash
+# Ensure branch is pushed
+git fetch origin
+REMOTE_EXISTS=$(git branch -r --list "origin/$CURRENT")
+[ -z "$REMOTE_EXISTS" ] && {
+  echo "Branch not pushed to remote. Pushing..."
+  git push -u origin $CURRENT
+}
+
+# Check for uncommitted changes
+DIRTY=$(git status --porcelain | wc -l)
+[ "$DIRTY" -gt 0 ] && {
+  echo "⚠️ Uncommitted changes detected"
+  echo "→ Run /gitflow commit first"
+  STOP
+}
+
+# Check if PR already exists
+EXISTING_PR=$(gh pr list --head "$CURRENT" --json number --jq '.[0].number' 2>/dev/null)
+[ -n "$EXISTING_PR" ] && {
+  echo "PR #$EXISTING_PR already exists for this branch"
+  echo "→ View: gh pr view $EXISTING_PR"
+  STOP
+}
+```
+
+### 4. Run Pre-PR Checks
+
+```bash
+# Build check
+echo "Running build check..."
+dotnet build --no-restore 2>&1 || {
+  echo "❌ Build failed. Fix before creating PR."
+  STOP
+}
+
+# Migration check
+echo "Checking migrations..."
+dotnet ef migrations list 2>&1 || echo "No migrations or EF Core not configured"
+```
+
+### 5. Generate PR Content
+
+**Title:**
+```bash
+BRANCH_NAME=$(echo $CURRENT | sed 's/.*\///')
+BRANCH_TYPE=$(echo $CURRENT | cut -d'/' -f1)
+
+case "$BRANCH_TYPE" in
+  feature) TITLE="feat: $BRANCH_NAME" ;;
+  hotfix)  TITLE="fix: $BRANCH_NAME" ;;
+  release) TITLE="release: v$(grep -oP '"current":\s*"\K[^"]+' .claude/gitflow/config.json)" ;;
+esac
+```
+
+**Body:**
+```markdown
+## Summary
+
+{Auto-generated from commit messages}
+
+## Changes
+
+{List of files changed with categories}
+
+## Testing
+
+- [ ] Build passes
+- [ ] Unit tests pass
+- [ ] Manual testing completed
+
+## EF Core Migrations
+
+{Migration status: None | Added | Modified}
+
+---
+
+🤖 Generated with [Claude Code](https://claude.ai/code)
+```
+
+### 6. Create Pull Request
+
+**GitHub:**
+```bash
+gh pr create \
+  --title "$TITLE" \
+  --body "$(cat <<'EOF'
+{PR_BODY}
+EOF
+)" \
+  --base "$TARGET_BRANCH" \
+  --head "$CURRENT"
+
+PR_URL=$(gh pr view --json url --jq '.url')
+PR_NUMBER=$(gh pr view --json number --jq '.number')
+```
+
+**Azure DevOps:**
+```bash
+az repos pr create \
+  --title "$TITLE" \
+  --description "{PR_BODY}" \
+  --source-branch "$CURRENT" \
+  --target-branch "$TARGET_BRANCH" \
+  --repository "$AZURE_REPO" \
+  --project "$AZURE_PROJECT" \
+  --org "https://dev.azure.com/$AZURE_ORG"
+
+PR_ID=$(az repos pr list --source-branch "$CURRENT" --query "[0].pullRequestId" -o tsv)
+```
+
+### 7. Add Labels (GitHub)
+
+```bash
+if [ "$GIT_PROVIDER" = "github" ]; then
+  case "$BRANCH_TYPE" in
+    feature) gh pr edit $PR_NUMBER --add-label "enhancement" ;;
+    hotfix)  gh pr edit $PR_NUMBER --add-label "bug,priority" ;;
+    release) gh pr edit $PR_NUMBER --add-label "release" ;;
+  esac
+fi
+```
+
+### 8. Store PR Info
+
+```bash
+# Save for merge step
+{
+  "pr_number": $PR_NUMBER,
+  "pr_url": "$PR_URL",
+  "target_branch": "$TARGET_BRANCH",
+  "git_provider": "$GIT_PROVIDER"
+}
+```
+
+### 9. Summary
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║                    PULL REQUEST CREATED                           ║
+╠══════════════════════════════════════════════════════════════════╣
+║  PR:     #{PR_NUMBER}                                             ║
+║  Title:  {TITLE}                                                  ║
+║  URL:    {PR_URL}                                                 ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Source: {CURRENT}                                                ║
+║  Target: {TARGET_BRANCH}                                          ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Checks:                                                          ║
+║  - Build: ✅                                                      ║
+║  - Migrations: {status}                                           ║
+╠══════════════════════════════════════════════════════════════════╣
+║  NEXT STEPS:                                                      ║
+║  1. Wait for CI checks                                            ║
+║  2. Request review                                                ║
+║  3. After approval: /gitflow merge                                ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## ERROR HANDLING:
+
+| Error | Solution |
+|-------|----------|
+| Branch not pushed | Auto-push before PR |
+| PR already exists | Show existing PR |
+| Build fails | Fix and re-run |
+| No git provider | Manual PR creation |
+
+---
+
+## SUCCESS CRITERIA:
+
+- PR created with proper target
+- Title and body generated
+- Labels added (if GitHub)
+- PR number stored for merge step
+
+## NEXT STEP:
+
+Wait for review, then `/gitflow merge`.

package/templates/skills/gitflow/steps/step-start.md

@@ -0,0 +1,234 @@
+---
+name: step-start
+description: Create new branch with worktree
+next_step: null
+---
+
+# Step: START - Create Branch
+
+## YOUR TASK:
+
+Create a new feature/release/hotfix branch with optional worktree setup.
+
+**ULTRA THINK about branch naming and base selection.**
+
+---
+
+## INPUT PARSING:
+
+```
+{branch_type} = feature | release | hotfix
+{branch_name} = normalized name (kebab-case)
+{no_worktree} = --no-worktree flag present
+```
+
+**From flags:**
+- `-f {name}` → branch_type=feature, branch_name={name}
+- `-r {name}` → branch_type=release, branch_name={name}
+- `-h {name}` → branch_type=hotfix, branch_name={name}
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Analyze Context
+
+```bash
+CURRENT_BRANCH=$(git branch --show-current)
+git fetch origin --quiet
+
+# Version detection
+VERSION=$(grep -oP '"current":\s*"\K[^"]+' .claude/gitflow/config.json 2>/dev/null || echo "0.1.0")
+LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "none")
+
+# Develop ahead of main?
+DEVELOP_AHEAD=$(git rev-list --count origin/main..origin/develop 2>/dev/null || echo "0")
+
+# Working directory status
+DIRTY=$(git status --porcelain | wc -l)
+```
+
+**Display:**
+```
+Current: {CURRENT_BRANCH} | Version: {VERSION} | Tag: {LAST_TAG}
+Develop → Main: {DEVELOP_AHEAD} commits {DEVELOP_AHEAD > 10 ? "(Release recommended)" : ""}
+```
+
+### 2. Interactive Questions (if no args)
+
+**If branch_type missing:**
+```yaml
+AskUserQuestion:
+  header: "Type"
+  question: "What type of branch?"
+  options:
+    - label: "Feature"
+      description: "New feature from develop"
+    - label: "Release v{X.Y+1.0}"
+      description: "Prepare release from develop"
+    - label: "Hotfix"
+      description: "Urgent fix from main"
+```
+
+**If branch_name missing:**
+```yaml
+AskUserQuestion:
+  header: "Name"
+  question: "Branch name? (will be normalized to kebab-case)"
+  # Free text input
+```
+
+### 3. Normalize and Validate
+
+```bash
+# Normalize name
+normalize_branch_name() {
+  echo "$1" | tr '[:upper:]' '[:lower:]' | \
+    sed 'y/àâäéèêëïîôùûüçœæ/aaaeeeeiioouucoa/' | \
+    sed "s/[ _']/-/g" | sed 's/[^a-z0-9-]//g' | \
+    sed 's/--*/-/g' | sed 's/^-//;s/-$//' | cut -c1-50
+}
+
+BRANCH_NAME=$(normalize_branch_name "$branch_name")
+FULL_BRANCH="${branch_type}/${BRANCH_NAME}"
+
+# Check if exists
+LOCAL_EXISTS=$(git branch --list "$FULL_BRANCH")
+REMOTE_EXISTS=$(git branch -r --list "origin/$FULL_BRANCH")
+
+[ -n "$LOCAL_EXISTS" ] || [ -n "$REMOTE_EXISTS" ] && {
+  echo "ERROR: Branch '$FULL_BRANCH' already exists"
+  # Options: Different name | Checkout existing | Delete and recreate
+}
+```
+
+### 4. Determine Base Branch
+
+| Type | Base Branch | Target |
+|------|-------------|--------|
+| feature | develop | develop |
+| release | develop | main + develop |
+| hotfix | main | main + develop |
+
+```bash
+case "$branch_type" in
+  feature) BASE_BRANCH="develop"; TARGET="develop" ;;
+  release) BASE_BRANCH="develop"; TARGET="main" ;;
+  hotfix)  BASE_BRANCH="main"; TARGET="main" ;;
+esac
+```
+
+### 5. Handle Dirty Working Directory
+
+```bash
+[ "$DIRTY" -gt 0 ] && {
+  echo "Working directory has uncommitted changes"
+  # Options: Stash | Commit | Continue anyway | Cancel
+}
+```
+
+### 6. Create Branch and Worktree
+
+**Read worktree mode from config:**
+```bash
+WORKTREE_MODE=$(grep -oP '"mode":\s*"\K[^"]+' .claude/gitflow/config.json 2>/dev/null || echo "organized")
+```
+
+**Mode: organized**
+```bash
+case "$branch_type" in
+  feature) WORKTREE_PATH="../features/$BRANCH_NAME" ;;
+  release) WORKTREE_PATH="../releases/v$VERSION" ;;
+  hotfix)  WORKTREE_PATH="../hotfixes/$BRANCH_NAME" ;;
+esac
+
+mkdir -p "$(dirname $WORKTREE_PATH)"
+git worktree add -b "$FULL_BRANCH" "$WORKTREE_PATH" "origin/$BASE_BRANCH"
+```
+
+**Mode: --no-worktree**
+```bash
+git checkout "$BASE_BRANCH" && git pull origin "$BASE_BRANCH"
+git checkout -b "$FULL_BRANCH"
+```
+
+### 7. Create Local DB Config (.NET)
+
+**If `appsettings.json` detected:**
+```bash
+PROJECT_NAME=$(basename $(pwd) | tr '[:upper:]' '[:lower:]')
+DB_NAME="${PROJECT_NAME}_${branch_type}_${BRANCH_NAME}" | cut -c1-63
+
+cat > "$WORKTREE_PATH/appsettings.Local.json" << EOF
+{
+  "ConnectionStrings": {
+    "DefaultConnection": "Server=localhost;Database=${DB_NAME};Trusted_Connection=true;TrustServerCertificate=true"
+  }
+}
+EOF
+```
+
+### 8. Store State
+
+```bash
+# Save to state for next steps
+{
+  "branch_type": "{branch_type}",
+  "branch_name": "{FULL_BRANCH}",
+  "base_branch": "{BASE_BRANCH}",
+  "target_branch": "{TARGET}",
+  "worktree_path": "{WORKTREE_PATH}",
+  "version_current": "{VERSION}"
+}
+```
+
+### 9. Summary
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║                    {BRANCH_TYPE} CREATED                          ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Branch:   {FULL_BRANCH}                                          ║
+║  Base:     {BASE_BRANCH}                                          ║
+║  Target:   {TARGET}                                               ║
+║  Worktree: {WORKTREE_PATH}                                        ║
+╠══════════════════════════════════════════════════════════════════╣
+║  NEXT STEPS:                                                      ║
+║                                                                    ║
+║  1. Go to worktree:                                               ║
+║     cd {WORKTREE_PATH}                                            ║
+║                                                                    ║
+║  2. Make changes and commit:                                      ║
+║     /gitflow commit                                               ║
+║                                                                    ║
+║  3. Create pull request:                                          ║
+║     /gitflow pr                                                   ║
+║                                                                    ║
+║  4. After PR merged, finalize:                                    ║
+║     /gitflow finish                                               ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## ERROR HANDLING:
+
+| Error | Solution |
+|-------|----------|
+| Branch exists | Offer: rename, checkout, or delete |
+| Dirty working directory | Offer: stash, commit, or continue |
+| Worktree path exists | Remove orphan or use different path |
+| Base branch behind remote | Pull before creating |
+
+---
+
+## SUCCESS CRITERIA:
+
+- Branch created from correct base
+- Worktree set up (if enabled)
+- Local config created (if .NET)
+- State stored for subsequent steps
+
+## NEXT STEP:
+
+User works on code, then runs `/gitflow commit`.

package/templates/skills/gitflow/steps/step-sync.md

@@ -0,0 +1,200 @@
+---
+name: step-sync
+description: Sync with remote and rebase if behind
+next_step: null
+---
+
+# Step: SYNC - Synchronize with Remote
+
+## YOUR TASK:
+
+Fetch from remote, detect divergence, push local commits, and rebase if behind base branch.
+
+**ULTRA THINK about merge conflicts.**
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Fetch Remote State
+
+```bash
+git fetch origin --quiet
+CURRENT=$(git rev-parse --abbrev-ref HEAD)
+
+# Determine base branch
+case "$CURRENT" in
+  feature/*) BASE_BRANCH="develop" ;;
+  release/*) BASE_BRANCH="develop" ;;
+  hotfix/*)  BASE_BRANCH="main" ;;
+  *)         BASE_BRANCH="develop" ;;
+esac
+```
+
+### 2. Analyze Divergence
+
+```bash
+# Current branch vs remote
+AHEAD=$(git rev-list --count origin/$CURRENT..HEAD 2>/dev/null || echo "0")
+BEHIND=$(git rev-list --count HEAD..origin/$CURRENT 2>/dev/null || echo "0")
+
+# Current branch vs base branch
+BASE_AHEAD=$(git rev-list --count origin/$BASE_BRANCH..HEAD 2>/dev/null || echo "0")
+BASE_BEHIND=$(git rev-list --count HEAD..origin/$BASE_BRANCH 2>/dev/null || echo "0")
+```
+
+**State matrix:**
+
+| Ahead | Behind | State | Action |
+|-------|--------|-------|--------|
+| 0 | 0 | Synced | Nothing to do |
+| >0 | 0 | Ahead | Push |
+| 0 | >0 | Behind | Pull |
+| >0 | >0 | Diverged | Pull --rebase + Push |
+
+### 3. Display Status
+
+```
+Sync Status: {CURRENT}
+
+| Remote | Ahead | Behind | Status |
+|--------|-------|--------|--------|
+| origin/{CURRENT} | {AHEAD} | {BEHIND} | {state} |
+| origin/{BASE_BRANCH} | {BASE_AHEAD} | {BASE_BEHIND} | {state} |
+```
+
+### 4. Push Local Commits
+
+```bash
+[ "$AHEAD" -gt 0 ] && {
+  echo "Pushing $AHEAD commit(s) to origin/$CURRENT..."
+  git push origin $CURRENT
+}
+```
+
+### 5. Pull Remote Commits
+
+```bash
+[ "$BEHIND" -gt 0 ] && {
+  echo "Pulling $BEHIND commit(s) from origin/$CURRENT..."
+
+  # Check for uncommitted changes
+  DIRTY=$(git status --porcelain | wc -l)
+  [ "$DIRTY" -gt 0 ] && {
+    git stash push -m "sync-stash-$(date +%s)"
+    STASHED=true
+  }
+
+  git pull --rebase origin $CURRENT
+
+  [ "$STASHED" = true ] && git stash pop
+}
+```
+
+### 6. Rebase on Base Branch (if behind)
+
+```bash
+[ "$BASE_BEHIND" -gt 0 ] && {
+  echo "Branch is $BASE_BEHIND commits behind $BASE_BRANCH"
+
+  if [ "$auto_mode" = true ]; then
+    # Auto rebase
+    git rebase origin/$BASE_BRANCH
+  else
+    # Ask user
+    AskUserQuestion:
+      header: "Rebase"
+      question: "Rebase on $BASE_BRANCH? ($BASE_BEHIND commits behind)"
+      options:
+        - label: "Yes (Recommended)"
+          description: "Rebase to include latest changes"
+        - label: "No"
+          description: "Keep current base"
+  fi
+}
+```
+
+### 7. Handle Rebase Conflicts
+
+```bash
+# If rebase has conflicts
+if [ -d ".git/rebase-merge" ] || [ -d ".git/rebase-apply" ]; then
+  echo "⚠️ REBASE CONFLICT DETECTED"
+
+  CONFLICTS=$(git diff --name-only --diff-filter=U)
+  echo "Conflicting files:"
+  echo "$CONFLICTS"
+
+  # Check for migration conflicts
+  MIGRATION_CONFLICTS=$(echo "$CONFLICTS" | grep "Migrations/")
+  [ -n "$MIGRATION_CONFLICTS" ] && {
+    echo "⚠️ Migration conflicts detected!"
+    echo "Recommend: /efcore:rebase-snapshot"
+  }
+
+  # Options
+  AskUserQuestion:
+    header: "Conflict"
+    question: "How to handle conflicts?"
+    options:
+      - label: "Resolve manually"
+        description: "I'll fix conflicts and continue"
+      - label: "Abort rebase"
+        description: "Cancel and return to previous state"
+      - label: "Accept theirs (migrations)"
+        description: "Use base branch migrations, regenerate ours"
+fi
+```
+
+### 8. Force Push After Rebase
+
+```bash
+# After successful rebase
+if [ "$REBASED" = true ]; then
+  echo "Rebase complete. Force pushing..."
+  git push --force-with-lease origin $CURRENT
+fi
+```
+
+### 9. Summary
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║                    SYNC COMPLETE                                  ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Branch: {CURRENT}                                                ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Actions:                                                         ║
+║  {✅ Pushed {N} commits | ⬜ Nothing to push}                     ║
+║  {✅ Pulled {N} commits | ⬜ Nothing to pull}                     ║
+║  {✅ Rebased on {BASE_BRANCH} | ⬜ No rebase needed}              ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Status: In sync with remote                                      ║
+╠══════════════════════════════════════════════════════════════════╣
+║  NEXT: /gitflow pr                                                ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## ERROR HANDLING:
+
+| Error | Solution |
+|-------|----------|
+| Push rejected | Pull first, then push |
+| Rebase conflict | Resolve or abort |
+| Migration conflict | Use /efcore:rebase-snapshot |
+| Force push blocked | Check branch protection |
+
+---
+
+## SUCCESS CRITERIA:
+
+- All local commits pushed
+- All remote commits pulled
+- Rebased on base branch (if needed)
+- No conflicts remaining
+
+## NEXT STEP:
+
+User runs `/gitflow pr` to create pull request.