@atlashub/smartstack-cli 1.13.2 → 1.14.0

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

@@ -0,0 +1,209 @@
+---
+name: step-init
+description: Initialize GitFlow configuration and branches
+next_step: null
+---
+
+# Step: INIT - Initialize GitFlow
+
+## YOUR TASK:
+
+Set up GitFlow configuration, create main/develop branches, and configure worktree structure.
+
+**ULTRA THINK before creating configuration.**
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Detect Environment
+
+```bash
+# Check if already initialized
+[ -f ".claude/gitflow/config.json" ] && {
+  echo "GitFlow already initialized"
+  # Show current config and ask to reinitialize
+}
+
+# Detect git provider
+REMOTE_URL=$(git remote get-url origin 2>/dev/null || echo "")
+if [[ "$REMOTE_URL" == *"github.com"* ]]; then
+  GIT_PROVIDER="github"
+elif [[ "$REMOTE_URL" == *"dev.azure.com"* ]]; then
+  GIT_PROVIDER="azuredevops"
+else
+  GIT_PROVIDER="unknown"
+fi
+
+# Detect existing branches
+HAS_MAIN=$(git branch -r --list "origin/main" | wc -l)
+HAS_DEVELOP=$(git branch -r --list "origin/develop" | wc -l)
+```
+
+### 2. Configuration Questions
+
+```yaml
+AskUserQuestion:
+  - header: "Mode"
+    question: "How do you want to set up GitFlow?"
+    options:
+      - label: "Quick Setup (Recommended)"
+        description: "Auto-detect settings, create branches"
+      - label: "Custom Setup"
+        description: "Configure each option manually"
+      - label: "Existing Config"
+        description: "Use existing .claude/gitflow/config.json"
+
+  - header: "Worktrees"
+    question: "How should worktrees be organized?"
+    options:
+      - label: "Organized (Recommended)"
+        description: "../features/, ../releases/, ../hotfixes/"
+      - label: "Adjacent"
+        description: "../worktrees/{type}/"
+      - label: "Disabled"
+        description: "No worktrees, use git checkout"
+```
+
+### 3. Create Branches (if needed)
+
+```bash
+# Ensure we have main
+[ "$HAS_MAIN" -eq 0 ] && {
+  git checkout -b main
+  git push -u origin main
+}
+
+# Ensure we have develop
+[ "$HAS_DEVELOP" -eq 0 ] && {
+  git checkout main
+  git checkout -b develop
+  git push -u origin develop
+}
+```
+
+### 4. Create Directory Structure
+
+```bash
+mkdir -p .claude/gitflow/{plans,logs,cache,backup}
+
+# Create worktree directories if mode != disabled
+case "$WORKTREE_MODE" in
+  organized)
+    mkdir -p ../features ../releases ../hotfixes
+    ;;
+  adjacent)
+    mkdir -p ../worktrees/{features,releases,hotfixes}
+    ;;
+esac
+```
+
+### 5. Create Configuration
+
+**Write `.claude/gitflow/config.json`:**
+
+```json
+{
+  "version": "2.0.0",
+  "repository": {
+    "name": "{repo_name}",
+    "defaultBranch": "main",
+    "remoteUrl": "{remote_url}"
+  },
+  "git": {
+    "provider": "{github|azuredevops}",
+    "branches": {
+      "main": "main",
+      "develop": "develop"
+    },
+    "prefixes": {
+      "feature": "feature/",
+      "release": "release/",
+      "hotfix": "hotfix/"
+    }
+  },
+  "worktrees": {
+    "enabled": true,
+    "mode": "{organized|adjacent|disabled}",
+    "structure": {
+      "features": "../features",
+      "releases": "../releases",
+      "hotfixes": "../hotfixes"
+    }
+  },
+  "versioning": {
+    "strategy": "semver",
+    "current": "{X.Y.Z}",
+    "tagPrefix": "v",
+    "sources": ["csproj", "package.json", "VERSION"]
+  },
+  "efcore": {
+    "enabled": true,
+    "validateOnCommit": true,
+    "blockDestructive": true,
+    "migrationNaming": "{context}_v{version}_{sequence}_{Description}"
+  },
+  "workflow": {
+    "push": {
+      "afterCommit": "worktree"
+    },
+    "pr": {
+      "autoLabels": true,
+      "requireReview": true
+    }
+  },
+  "language": {
+    "code": "en"
+  }
+}
+```
+
+### 6. Detect Version
+
+```bash
+# Priority: csproj > Directory.Build.props > package.json > VERSION > tag
+VERSION=$(grep -oP '<Version>\K[^<]+' *.csproj 2>/dev/null | head -1)
+[ -z "$VERSION" ] && VERSION=$(grep -oP '<Version>\K[^<]+' Directory.Build.props 2>/dev/null)
+[ -z "$VERSION" ] && VERSION=$(grep -oP '"version":\s*"\K[^"]+' package.json 2>/dev/null)
+[ -z "$VERSION" ] && VERSION=$(cat VERSION 2>/dev/null)
+[ -z "$VERSION" ] && VERSION=$(git describe --tags --abbrev=0 2>/dev/null | sed 's/^v//')
+[ -z "$VERSION" ] && VERSION="0.1.0"
+```
+
+### 7. Summary
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║                    GITFLOW INITIALIZED                            ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Repository: {repo_name}                                          ║
+║  Provider:   {github|azuredevops}                                 ║
+║  Version:    {X.Y.Z}                                              ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Branches:                                                        ║
+║  - main:    ✅ Ready                                              ║
+║  - develop: ✅ Ready                                              ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Worktrees: {mode}                                                ║
+║  - ../features/  (for feature branches)                           ║
+║  - ../releases/  (for release branches)                           ║
+║  - ../hotfixes/  (for hotfix branches)                            ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Config: .claude/gitflow/config.json                              ║
+╠══════════════════════════════════════════════════════════════════╣
+║  NEXT: /gitflow start feature <name>                              ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## SUCCESS CRITERIA:
+
+- Configuration file created
+- main and develop branches exist
+- Worktree directories created (if enabled)
+- Version detected and stored
+
+## NEXT STEP:
+
+Init is standalone. User can now run `/gitflow start feature <name>`.

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

@@ -0,0 +1,225 @@
+---
+name: step-merge
+description: Review checklist and merge PR
+next_step: steps/step-finish.md
+---
+
+# Step: MERGE - Review and Merge PR
+
+## YOUR TASK:
+
+Run through review checklist and merge the pull request with appropriate strategy.
+
+**ULTRA THINK about merge safety.**
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Load PR Context
+
+```bash
+CURRENT=$(git rev-parse --abbrev-ref HEAD)
+GIT_PROVIDER=$(grep -oP '"provider":\s*"\K[^"]+' .claude/gitflow/config.json 2>/dev/null || echo "github")
+
+# Get PR number
+if [ "$GIT_PROVIDER" = "github" ]; then
+  PR_NUMBER=$(gh pr list --head "$CURRENT" --json number --jq '.[0].number')
+  PR_STATUS=$(gh pr view $PR_NUMBER --json state,mergeable,reviews --jq '.')
+elif [ "$GIT_PROVIDER" = "azuredevops" ]; then
+  PR_NUMBER=$(az repos pr list --source-branch "$CURRENT" --query "[0].pullRequestId" -o tsv)
+  PR_STATUS=$(az repos pr show --id $PR_NUMBER --query "{status:status,mergeStatus:mergeStatus}")
+fi
+
+[ -z "$PR_NUMBER" ] && {
+  echo "❌ No PR found for branch $CURRENT"
+  echo "→ Run /gitflow pr first"
+  STOP
+}
+```
+
+### 2. Display Review Checklist
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║                    PR REVIEW CHECKLIST                            ║
+╠══════════════════════════════════════════════════════════════════╣
+║  PR #${PR_NUMBER}: ${PR_TITLE}                                    ║
+╠══════════════════════════════════════════════════════════════════╣
+
+## Code Quality
+- [ ] Code follows project conventions
+- [ ] No unnecessary complexity
+- [ ] No code duplication
+- [ ] Variable/function names are clear
+
+## Security
+- [ ] No hardcoded secrets
+- [ ] Input validation present
+- [ ] Authentication/authorization correct
+- [ ] No SQL injection risks
+
+## Testing
+- [ ] Unit tests added/updated
+- [ ] Integration tests pass
+- [ ] Manual testing completed
+
+## EF Core (if applicable)
+- [ ] Migration files complete (3 files)
+- [ ] No destructive operations (or confirmed)
+- [ ] Snapshot synced with base
+
+## Documentation
+- [ ] Code comments where needed
+- [ ] API docs updated (if applicable)
+- [ ] README updated (if applicable)
+
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+### 3. Check CI Status
+
+```bash
+if [ "$GIT_PROVIDER" = "github" ]; then
+  CI_STATUS=$(gh pr checks $PR_NUMBER --json state --jq '.[].state' | sort -u)
+
+  [[ "$CI_STATUS" == *"FAILURE"* ]] && {
+    echo "❌ CI checks failing"
+    gh pr checks $PR_NUMBER
+
+    if [ "$auto_mode" != true ]; then
+      AskUserQuestion:
+        header: "CI"
+        question: "CI checks are failing. Continue anyway?"
+        options:
+          - label: "Wait for fix"
+          - label: "Merge anyway (not recommended)"
+    fi
+  }
+fi
+```
+
+### 4. Check Review Status
+
+```bash
+if [ "$GIT_PROVIDER" = "github" ]; then
+  REVIEWS=$(gh pr view $PR_NUMBER --json reviews --jq '.reviews | map(select(.state == "APPROVED")) | length')
+  REQUIRED_REVIEWS=$(gh api repos/:owner/:repo --jq '.default_branch_protection.required_pull_request_reviews.required_approving_review_count // 0')
+
+  [ "$REVIEWS" -lt "$REQUIRED_REVIEWS" ] && {
+    echo "⚠️ Needs $REQUIRED_REVIEWS approvals, has $REVIEWS"
+  }
+fi
+```
+
+### 5. Determine Merge Strategy
+
+```bash
+BRANCH_TYPE=$(echo $CURRENT | cut -d'/' -f1)
+
+case "$BRANCH_TYPE" in
+  feature)
+    MERGE_STRATEGY="squash"
+    DELETE_BRANCH=true
+    ;;
+  release|hotfix)
+    MERGE_STRATEGY="merge"
+    DELETE_BRANCH=true
+    MERGE_BACK="develop"
+    ;;
+esac
+```
+
+### 6. Final Confirmation
+
+```yaml
+AskUserQuestion:
+  header: "Merge"
+  question: "Ready to merge PR #$PR_NUMBER?"
+  options:
+    - label: "Yes, merge now"
+      description: "Strategy: $MERGE_STRATEGY, Delete branch: $DELETE_BRANCH"
+    - label: "No, wait"
+      description: "Cancel merge"
+```
+
+### 7. Execute Merge
+
+**GitHub:**
+```bash
+case "$MERGE_STRATEGY" in
+  squash)
+    gh pr merge $PR_NUMBER --squash --delete-branch
+    ;;
+  merge)
+    gh pr merge $PR_NUMBER --merge --delete-branch
+    ;;
+esac
+```
+
+**Azure DevOps:**
+```bash
+case "$MERGE_STRATEGY" in
+  squash)
+    az repos pr update --id $PR_NUMBER --status completed --squash true --delete-source-branch true
+    ;;
+  merge)
+    az repos pr update --id $PR_NUMBER --status completed --squash false --delete-source-branch true
+    ;;
+esac
+```
+
+### 8. Verify Merge
+
+```bash
+git fetch origin
+MERGED=$(git branch -r --merged origin/$TARGET_BRANCH | grep "$CURRENT" | wc -l)
+
+[ "$MERGED" -eq 0 ] && {
+  echo "⚠️ Merge verification failed"
+  # Check if PR is actually merged
+}
+```
+
+### 9. Summary
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║                    PR MERGED                                      ║
+╠══════════════════════════════════════════════════════════════════╣
+║  PR:       #{PR_NUMBER}                                           ║
+║  Strategy: {MERGE_STRATEGY}                                       ║
+║  Target:   {TARGET_BRANCH}                                        ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Branch:   {deleted | kept}                                       ║
+{if MERGE_BACK}
+║  Merge back: {MERGE_BACK} pending                                 ║
+{endif}
+╠══════════════════════════════════════════════════════════════════╣
+║  NEXT: /gitflow finish                                            ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## ERROR HANDLING:
+
+| Error | Solution |
+|-------|----------|
+| CI failing | Wait for fix or force merge |
+| No reviews | Request review or bypass |
+| Merge conflicts | Rebase and retry |
+| Branch protection | Request admin merge |
+
+---
+
+## SUCCESS CRITERIA:
+
+- Review checklist completed
+- CI checks passing (or bypassed)
+- PR merged with correct strategy
+- Source branch deleted
+
+## NEXT STEP:
+
+Proceed to `/gitflow finish` (automatically or manually).

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

@@ -0,0 +1,208 @@
+---
+name: step-plan
+description: Generate integration plan with EF Core analysis
+next_step: null
+---
+
+# Step: PLAN - Integration Strategy
+
+## YOUR TASK:
+
+Analyze branch state, detect migration conflicts, and generate a detailed integration plan.
+
+**ULTRA THINK about merge strategy and migration handling.**
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Analyze Branch Context
+
+```bash
+CURRENT=$(git rev-parse --abbrev-ref HEAD)
+git fetch origin --quiet
+
+# Determine target based on branch type
+case "$CURRENT" in
+  feature/*)
+    BASE_BRANCH="develop"
+    MERGE_STRATEGY="squash"
+    ;;
+  release/*)
+    BASE_BRANCH="main"
+    MERGE_STRATEGY="merge"
+    MERGE_BACK="develop"
+    ;;
+  hotfix/*)
+    BASE_BRANCH="main"
+    MERGE_STRATEGY="merge"
+    MERGE_BACK="develop"
+    ;;
+esac
+
+# Get commits
+COMMITS=$(git rev-list --count origin/$BASE_BRANCH..HEAD)
+COMMIT_LIST=$(git log --oneline origin/$BASE_BRANCH..HEAD)
+```
+
+### 2. Analyze EF Core Migrations
+
+```bash
+# Find migration files in branch
+BRANCH_MIGRATIONS=$(git diff --name-only origin/$BASE_BRANCH...HEAD | grep "Migrations/")
+
+# Find migrations in base branch
+BASE_MIGRATIONS=$(git ls-tree -r --name-only origin/$BASE_BRANCH | grep "Migrations/")
+
+# Check for snapshot divergence
+SNAPSHOT_BRANCH=$(git show HEAD:$(find . -name "*ModelSnapshot.cs" -path "*/Migrations/*" | head -1) 2>/dev/null | md5sum)
+SNAPSHOT_BASE=$(git show origin/$BASE_BRANCH:$(find . -name "*ModelSnapshot.cs" -path "*/Migrations/*" | head -1) 2>/dev/null | md5sum)
+
+SNAPSHOT_DIVERGED=$([ "$SNAPSHOT_BRANCH" != "$SNAPSHOT_BASE" ] && echo "true" || echo "false")
+```
+
+### 3. Detect Conflicts
+
+**Migration conflicts:**
+```bash
+if [ "$SNAPSHOT_DIVERGED" = "true" ]; then
+  echo "⚠️ ModelSnapshot has diverged from $BASE_BRANCH"
+
+  # Check if base has new migrations we don't have
+  NEW_BASE_MIGRATIONS=$(git diff --name-only HEAD...origin/$BASE_BRANCH | grep "Migrations/" | grep -v "ModelSnapshot")
+
+  [ -n "$NEW_BASE_MIGRATIONS" ] && {
+    CONFLICT_TYPE="migration"
+    CONFLICT_RESOLUTION="rebase-snapshot"
+  }
+fi
+```
+
+**Code conflicts:**
+```bash
+# Dry-run merge to detect conflicts
+git merge-tree $(git merge-base HEAD origin/$BASE_BRANCH) HEAD origin/$BASE_BRANCH > /tmp/merge-tree 2>&1
+CODE_CONFLICTS=$(grep -c "<<<<<<" /tmp/merge-tree || echo "0")
+```
+
+### 4. Determine Integration Strategy
+
+| Scenario | Strategy |
+|----------|----------|
+| No conflicts | Direct merge |
+| Code conflicts only | Rebase + resolve |
+| Migration conflicts | `/efcore:rebase-snapshot` first |
+| Both | Migration first, then code |
+
+### 5. Generate Plan Document
+
+**Write to `.claude/gitflow/plans/{branch-name}_{date}.md`:**
+
+```markdown
+# Integration Plan: {CURRENT} → {BASE_BRANCH}
+
+**Generated:** {timestamp}
+**Status:** PENDING
+
+## Summary
+
+| Field | Value |
+|-------|-------|
+| Source | {CURRENT} |
+| Target | {BASE_BRANCH} |
+| Commits | {COMMITS} |
+| Strategy | {MERGE_STRATEGY} |
+| Merge Back | {MERGE_BACK or "N/A"} |
+
+## Commits to Integrate
+
+{COMMIT_LIST}
+
+## EF Core Analysis
+
+| Check | Status |
+|-------|--------|
+| Branch migrations | {count} |
+| Base migrations | {count} |
+| Snapshot diverged | {yes/no} |
+| Conflict type | {none/migration/code/both} |
+
+## Pre-Integration Steps
+
+{if migration conflict}
+1. [ ] Run `/efcore:rebase-snapshot`
+2. [ ] Verify migration generates same schema
+3. [ ] Run `/gitflow sync`
+{endif}
+
+{if code conflict}
+1. [ ] Run `/gitflow sync` (includes rebase)
+2. [ ] Resolve conflicts manually
+3. [ ] Verify build passes
+{endif}
+
+## Integration Steps
+
+1. [ ] Create PR: `/gitflow pr`
+2. [ ] Review and approve
+3. [ ] Merge: `/gitflow merge`
+{if release or hotfix}
+4. [ ] Merge back to develop
+5. [ ] Create tag: v{VERSION}
+{endif}
+6. [ ] Cleanup: `/gitflow finish`
+
+## Post-Integration
+
+- [ ] Verify CI/CD passes
+- [ ] Verify migrations applied
+- [ ] Delete source branch
+- [ ] Remove worktree
+```
+
+### 6. Display Plan Summary
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║                    INTEGRATION PLAN                               ║
+╠══════════════════════════════════════════════════════════════════╣
+║  {CURRENT} → {BASE_BRANCH}                                        ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Commits:    {COMMITS}                                            ║
+║  Strategy:   {MERGE_STRATEGY}                                     ║
+║  Migrations: {migration_status}                                   ║
+║  Conflicts:  {conflict_status}                                    ║
+╠══════════════════════════════════════════════════════════════════╣
+{if conflicts}
+║  ⚠️ PRE-REQUISITES:                                               ║
+║  {list of required steps}                                         ║
+╠══════════════════════════════════════════════════════════════════╣
+{endif}
+║  Plan saved: .claude/gitflow/plans/{filename}                     ║
+╠══════════════════════════════════════════════════════════════════╣
+║  NEXT: {/efcore:rebase-snapshot | /gitflow pr}                    ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## BLOCKING CONDITIONS:
+
+- **Migration conflict** → Must run `/efcore:rebase-snapshot` first
+- **Destructive migrations** → Require explicit confirmation
+- **Build failure** → Fix before proceeding
+
+---
+
+## SUCCESS CRITERIA:
+
+- Branch context analyzed
+- Migration status determined
+- Conflicts identified
+- Plan document generated
+- Clear next steps provided
+
+## NEXT STEP:
+
+- If conflicts: Resolve per plan
+- If clean: `/gitflow pr`