@atlashub/smartstack-cli 1.13.2 → 1.14.1

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,334 @@
+---
+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 Environment Config (Backend + Frontend)
+
+**Detect project structure:**
+```bash
+# Find API project directory
+API_DIR=$(find "$WORKTREE_PATH" -type d -name "*.Api" -path "*/src/*" | head -1)
+# Find Web project directory
+WEB_DIR=$(find "$WORKTREE_PATH" -type d -name "*-web" -path "*/web/*" | head -1)
+
+# Generate unique ports based on branch name hash (to avoid conflicts between worktrees)
+HASH=$(echo "$BRANCH_NAME" | md5sum | cut -c1-4)
+HASH_NUM=$((16#$HASH % 100))
+API_PORT=$((5200 + HASH_NUM))
+WEB_PORT=$((5300 + HASH_NUM))
+
+# Project and DB naming
+PROJECT_NAME=$(basename $(pwd) | tr '[:upper:]' '[:lower:]')
+DB_NAME=$(echo "${PROJECT_NAME}_${branch_type}_${BRANCH_NAME}" | cut -c1-63)
+```
+
+#### 7a. Backend: appsettings.Local.json
+
+**If API project detected:**
+```bash
+[ -n "$API_DIR" ] && [ -f "$API_DIR/appsettings.json" ] && {
+  cat > "$API_DIR/appsettings.Local.json" << EOF
+{
+  "ConnectionStrings": {
+    "DefaultConnection": "Server=localhost;Database=${DB_NAME};Trusted_Connection=true;TrustServerCertificate=true"
+  },
+  "Authentication": {
+    "FrontendUrl": "http://localhost:${WEB_PORT}"
+  },
+  "Kestrel": {
+    "Endpoints": {
+      "Http": {
+        "Url": "http://localhost:${API_PORT}"
+      }
+    }
+  },
+  "Serilog": {
+    "MinimumLevel": {
+      "Default": "Debug"
+    }
+  }
+}
+EOF
+  echo "Created: $API_DIR/appsettings.Local.json (DB: $DB_NAME, Port: $API_PORT)"
+}
+```
+
+#### 7b. Frontend: .env.local + npm script
+
+**If Web project detected:**
+```bash
+[ -n "$WEB_DIR" ] && [ -f "$WEB_DIR/package.json" ] && {
+  # Create .env.local
+  cat > "$WEB_DIR/.env.local" << EOF
+# Local environment configuration
+# Generated by /gitflow:start for branch: ${FULL_BRANCH}
+# Run with: npm run local
+
+VITE_API_URL=http://localhost:${API_PORT}
+VITE_APP_ENV=local
+VITE_DEBUG=true
+EOF
+  echo "Created: $WEB_DIR/.env.local (API: localhost:$API_PORT)"
+
+  # Add "local" script to package.json if not exists
+  if ! grep -q '"local"' "$WEB_DIR/package.json"; then
+    # Use Node.js to safely modify package.json
+    node -e "
+      const fs = require('fs');
+      const pkg = JSON.parse(fs.readFileSync('$WEB_DIR/package.json', 'utf8'));
+      if (!pkg.scripts.local) {
+        pkg.scripts.local = 'vite --mode local --port ${WEB_PORT}';
+        fs.writeFileSync('$WEB_DIR/package.json', JSON.stringify(pkg, null, 2) + '\n');
+        console.log('Added script: npm run local');
+      }
+    "
+  fi
+}
+```
+
+#### 7c. Summary of local config
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  LOCAL ENVIRONMENT CONFIGURED                               │
+├─────────────────────────────────────────────────────────────┤
+│  Database:  ${DB_NAME}                                      │
+│  API Port:  ${API_PORT}  →  dotnet run --environment Local  │
+│  Web Port:  ${WEB_PORT}  →  npm run local                   │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### 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}",
+  "local_config": {
+    "database": "{DB_NAME}",
+    "api_port": "{API_PORT}",
+    "web_port": "{WEB_PORT}",
+    "api_dir": "{API_DIR}",
+    "web_dir": "{WEB_DIR}"
+  }
+}
+```
+
+### 9. Summary
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║                    {BRANCH_TYPE} CREATED                          ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Branch:   {FULL_BRANCH}                                          ║
+║  Base:     {BASE_BRANCH}                                          ║
+║  Target:   {TARGET}                                               ║
+║  Worktree: {WORKTREE_PATH}                                        ║
+╠══════════════════════════════════════════════════════════════════╣
+║  LOCAL ENVIRONMENT:                                               ║
+║  Database: {DB_NAME}                                              ║
+║  API:      http://localhost:{API_PORT}                            ║
+║  Web:      http://localhost:{WEB_PORT}                            ║
+╠══════════════════════════════════════════════════════════════════╣
+║  NEXT STEPS:                                                      ║
+║                                                                    ║
+║  1. Go to worktree:                                               ║
+║     cd {WORKTREE_PATH}                                            ║
+║                                                                    ║
+║  2. Start local environment:                                      ║
+║     # Terminal 1 - Backend:                                       ║
+║     cd src/SmartStack.Api && dotnet run --environment Local       ║
+║     # Terminal 2 - Frontend:                                      ║
+║     cd web/smartstack-web && npm run local                        ║
+║                                                                    ║
+║  3. Make changes and commit:                                      ║
+║     /gitflow commit                                               ║
+║                                                                    ║
+║  4. Create pull request:                                          ║
+║     /gitflow pr                                                   ║
+║                                                                    ║
+║  5. 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)
+- Backend local config created: `appsettings.Local.json` (if .NET API detected)
+- Frontend local config created: `.env.local` + `npm run local` script (if web project detected)
+- Ports synchronized between backend and frontend (unique per branch)
+- State stored for subsequent steps
+
+## NEXT STEP:
+
+User works on code, then runs `/gitflow commit`.