@atlashub/smartstack-cli 1.13.2 → 1.14.0

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

@@ -0,0 +1,255 @@
+---
+name: step-commit
+description: Commit with EF Core migration validation
+next_step: null
+---
+
+# Step: COMMIT - Migration-Aware Commits
+
+## YOUR TASK:
+
+Validate changes, check EF Core migrations, and create commit with proper message.
+
+**ULTRA THINK about migration safety.**
+
+---
+
+## INPUT PARSING:
+
+```
+{commit_message} = optional message from args
+{validate_only} = --validate flag (check without committing)
+{dry_run} = --dry-run flag (simulate)
+```
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 0. Pre-commit Guards
+
+**0.1 Branch Protection:**
+```bash
+CURRENT=$(git rev-parse --abbrev-ref HEAD)
+
+# BLOCK: main
+[[ "$CURRENT" == "main" ]] && {
+  echo "⛔ COMMIT BLOCKED - main is protected"
+  echo "→ Use: /gitflow start hotfix <name>"
+  STOP
+}
+
+# WARNING: develop
+[[ "$CURRENT" == "develop" ]] && {
+  echo "⚠️ Direct commits to develop are discouraged"
+  # Offer RESCUE TO FEATURE
+}
+```
+
+**0.2 Rescue to Feature (if on develop):**
+```bash
+git fetch origin --quiet
+STAGED=$(git diff --cached --name-only | wc -l)
+MODIFIED=$(git diff --name-only | wc -l)
+UNTRACKED=$(git ls-files --others --exclude-standard | wc -l)
+LOCAL_COMMITS=$(git rev-list --count origin/develop..HEAD 2>/dev/null || echo "0")
+
+# If there are changes or commits, offer rescue
+[ "$STAGED" -gt 0 ] || [ "$MODIFIED" -gt 0 ] || [ "$LOCAL_COMMITS" -gt 0 ] && {
+  # Ask to rescue to feature branch
+  RESCUE_BRANCH="feature/rescue-$(date +%Y%m%d-%H%M%S)"
+  # Execute rescue flow...
+}
+```
+
+**0.3 Check Sync Status:**
+```bash
+BEHIND=$(git rev-list --count HEAD..origin/$CURRENT 2>/dev/null || echo "0")
+[ "$BEHIND" -gt 0 ] && echo "⚠️ Branch is $BEHIND commits behind → /gitflow sync"
+```
+
+### 1. Analyze Changes
+
+```bash
+STAGED=$(git diff --cached --name-only)
+MODIFIED=$(git diff --name-only)
+UNTRACKED=$(git ls-files --others --exclude-standard)
+
+# Nothing to commit?
+[ -z "$STAGED" ] && [ -z "$MODIFIED" ] && [ -z "$UNTRACKED" ] && {
+  echo "✓ Nothing to commit"
+  exit 0
+}
+```
+
+### 2. Detect EF Core Migrations
+
+```bash
+# Find migration files in changes
+MIGRATIONS=$(echo "$STAGED $MODIFIED $UNTRACKED" | tr ' ' '\n' | grep -E "Migrations/.*\.cs$")
+HAS_MIGRATIONS=$([ -n "$MIGRATIONS" ] && echo "true" || echo "false")
+
+if [ "$HAS_MIGRATIONS" = "true" ]; then
+  # Check for the 3 required files
+  MIGRATION_NAME=$(echo "$MIGRATIONS" | grep -v "Designer\|Snapshot" | head -1 | sed 's/.*\///' | sed 's/\.cs$//')
+
+  HAS_MAIN=$(echo "$MIGRATIONS" | grep -c "${MIGRATION_NAME}.cs")
+  HAS_DESIGNER=$(echo "$MIGRATIONS" | grep -c "${MIGRATION_NAME}.Designer.cs")
+  HAS_SNAPSHOT=$(echo "$MIGRATIONS" | grep -c "ModelSnapshot.cs")
+
+  [ "$HAS_MAIN" -eq 0 ] || [ "$HAS_DESIGNER" -eq 0 ] || [ "$HAS_SNAPSHOT" -eq 0 ] && {
+    echo "❌ INCOMPLETE MIGRATION"
+    echo "Required: Migration.cs + Designer.cs + ModelSnapshot.cs"
+    echo "Found: Main=$HAS_MAIN, Designer=$HAS_DESIGNER, Snapshot=$HAS_SNAPSHOT"
+    STOP
+  }
+fi
+```
+
+### 3. Check Destructive Operations (BLOCKING)
+
+```bash
+if [ "$HAS_MIGRATIONS" = "true" ]; then
+  DESTRUCTIVE=$(grep -l "DropTable\|DropColumn\|DeleteData" $MIGRATIONS 2>/dev/null)
+
+  [ -n "$DESTRUCTIVE" ] && {
+    echo "⚠️ DESTRUCTIVE OPERATIONS DETECTED"
+    grep -n "DropTable\|DropColumn\|DeleteData" $DESTRUCTIVE
+
+    # Require explicit confirmation
+    AskUserQuestion:
+      header: "Confirm"
+      question: "Destructive migration detected. Continue?"
+      options:
+        - label: "Yes, I understand the risks"
+        - label: "No, let me review"
+
+    # Log to audit trail
+    echo "$(date) - DESTRUCTIVE: $DESTRUCTIVE - User: $USER" >> .claude/gitflow/logs/audit.log
+  }
+fi
+```
+
+### 4. Stage All Changes
+
+```bash
+# Stage all changes
+git add -A
+
+# Show what will be committed
+echo "Files to commit:"
+git diff --cached --stat
+```
+
+### 5. Generate Commit Message
+
+**If no message provided:**
+
+```bash
+# Determine commit type from branch
+BRANCH_TYPE=$(echo $CURRENT | cut -d'/' -f1)
+case "$BRANCH_TYPE" in
+  feature) PREFIX="feat" ;;
+  hotfix)  PREFIX="fix" ;;
+  release) PREFIX="chore" ;;
+  *)       PREFIX="chore" ;;
+esac
+
+# Determine scope from branch name
+SCOPE=$(echo $CURRENT | cut -d'/' -f2 | cut -d'-' -f1)
+
+# If migrations present
+[ "$HAS_MIGRATIONS" = "true" ] && PREFIX="db(migrations)"
+
+# Generate message from diff analysis
+SUMMARY=$(git diff --cached --stat | tail -1 | sed 's/^ *//')
+```
+
+**Message format:**
+```
+{type}({scope}): {summary - 50 chars max}
+
+**CHANGE**
+PROBLEM: {what was wrong}
+SOLUTION: {what was done}
+IMPACT: {benefit}
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+```
+
+### 6. Create Commit
+
+```bash
+git commit -m "$(cat <<'EOF'
+{generated_message}
+EOF
+)"
+
+COMMIT_HASH=$(git rev-parse --short HEAD)
+```
+
+### 7. Auto-Push (based on config)
+
+```bash
+PUSH_MODE=$(grep -oP '"afterCommit":\s*"\K[^"]+' .claude/gitflow/config.json 2>/dev/null || echo "ask")
+
+case "$PUSH_MODE" in
+  always)
+    git push origin $CURRENT
+    PUSHED="yes"
+    ;;
+  worktree)
+    # Push if in worktree
+    [ -n "$(git worktree list | grep $(pwd))" ] && git push origin $CURRENT && PUSHED="yes"
+    ;;
+  ask)
+    # Ask user
+    ;;
+  never)
+    PUSHED="no"
+    ;;
+esac
+```
+
+### 8. Summary
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║                    COMMIT CREATED                                 ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Branch:  {CURRENT}                                               ║
+║  Commit:  {COMMIT_HASH}                                           ║
+║  Message: {first line of message}                                 ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Files:   {N} changed                                             ║
+║  EF Core: {✅ Valid | ⚠️ Destructive confirmed | N/A}             ║
+║  Pushed:  {yes | no | pending}                                    ║
+╠══════════════════════════════════════════════════════════════════╣
+║  NEXT: /gitflow pr                                                ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## ERROR HANDLING:
+
+| Error | Solution |
+|-------|----------|
+| Incomplete migration | Add missing files |
+| Build fails | `dotnet ef migrations remove` + fix |
+| Pre-commit hook fails | Fix issues, stage again, NEW commit |
+| Destructive operation | Confirm or modify migration |
+
+---
+
+## SUCCESS CRITERIA:
+
+- All files staged
+- Migrations validated (if present)
+- Destructive operations confirmed
+- Commit created with proper message
+- Pushed (if configured)
+
+## NEXT STEP:
+
+User continues coding or runs `/gitflow pr`.

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

@@ -0,0 +1,255 @@
+---
+name: step-finish
+description: Finalize branch - tag, merge back, cleanup
+next_step: null
+---
+
+# Step: FINISH - Finalize Branch
+
+## YOUR TASK:
+
+Create tags for releases/hotfixes, merge back to develop, clean up worktree and branch.
+
+**ULTRA THINK about version tagging.**
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Determine Branch Context
+
+```bash
+# Get current or specified branch
+BRANCH=${1:-$(git rev-parse --abbrev-ref HEAD)}
+BRANCH_TYPE=$(echo $BRANCH | cut -d'/' -f1)
+BRANCH_NAME=$(echo $BRANCH | cut -d'/' -f2)
+
+# Validate branch type
+case "$BRANCH_TYPE" in
+  feature|release|hotfix) ;;
+  main|develop)
+    echo "❌ Cannot finish main or develop branch"
+    STOP
+    ;;
+  *)
+    echo "❌ Unknown branch type: $BRANCH_TYPE"
+    STOP
+    ;;
+esac
+```
+
+### 2. Verify Merge Status
+
+```bash
+git fetch origin
+
+# Check if branch was merged
+case "$BRANCH_TYPE" in
+  feature)
+    MERGED=$(git branch -r --merged origin/develop | grep "$BRANCH" | wc -l)
+    TARGET="develop"
+    ;;
+  release|hotfix)
+    MERGED=$(git branch -r --merged origin/main | grep "$BRANCH" | wc -l)
+    TARGET="main"
+    ;;
+esac
+
+[ "$MERGED" -eq 0 ] && {
+  echo "⚠️ Branch $BRANCH not yet merged to $TARGET"
+  echo "→ Run /gitflow merge first"
+
+  if [ "$auto_mode" != true ]; then
+    AskUserQuestion:
+      header: "Continue"
+      question: "Branch not merged. Continue anyway?"
+      options:
+        - label: "No, merge first"
+        - label: "Yes, finish anyway"
+  fi
+}
+```
+
+### 3. Create Tag (Release/Hotfix only)
+
+```bash
+if [ "$BRANCH_TYPE" = "release" ] || [ "$BRANCH_TYPE" = "hotfix" ]; then
+  # Get version
+  VERSION=$(grep -oP '"current":\s*"\K[^"]+' .claude/gitflow/config.json 2>/dev/null)
+
+  # For hotfix, increment patch
+  if [ "$BRANCH_TYPE" = "hotfix" ]; then
+    MAJOR=$(echo $VERSION | cut -d'.' -f1)
+    MINOR=$(echo $VERSION | cut -d'.' -f2)
+    PATCH=$(echo $VERSION | cut -d'.' -f3)
+    VERSION="$MAJOR.$MINOR.$((PATCH + 1))"
+  fi
+
+  TAG_NAME="v$VERSION"
+
+  # Check if tag exists
+  TAG_EXISTS=$(git tag -l "$TAG_NAME")
+  [ -n "$TAG_EXISTS" ] && {
+    echo "⚠️ Tag $TAG_NAME already exists"
+    # Options: overwrite, different version, skip
+  }
+
+  # Create tag on main
+  git checkout main
+  git pull origin main
+  git tag -a "$TAG_NAME" -m "$BRANCH_TYPE: $BRANCH_NAME"
+  git push origin "$TAG_NAME"
+
+  echo "✅ Created tag: $TAG_NAME"
+fi
+```
+
+### 4. Merge Back to Develop (Release/Hotfix only)
+
+```bash
+if [ "$BRANCH_TYPE" = "release" ] || [ "$BRANCH_TYPE" = "hotfix" ]; then
+  echo "Merging $TAG_NAME back to develop..."
+
+  git checkout develop
+  git pull origin develop
+
+  # Merge with merge commit (preserve history)
+  git merge main -m "Merge $TAG_NAME back to develop"
+
+  # Handle conflicts
+  CONFLICTS=$(git diff --name-only --diff-filter=U | wc -l)
+  [ "$CONFLICTS" -gt 0 ] && {
+    echo "⚠️ Merge conflicts detected"
+    git diff --name-only --diff-filter=U
+
+    # Options: resolve, abort
+  }
+
+  git push origin develop
+  echo "✅ Merged back to develop"
+fi
+```
+
+### 5. Update Version (Release only)
+
+```bash
+if [ "$BRANCH_TYPE" = "release" ]; then
+  # Increment minor version for next development
+  MAJOR=$(echo $VERSION | cut -d'.' -f1)
+  MINOR=$(echo $VERSION | cut -d'.' -f2)
+  NEXT_VERSION="$MAJOR.$((MINOR + 1)).0"
+
+  # Update config
+  sed -i "s/\"current\": \"$VERSION\"/\"current\": \"$NEXT_VERSION\"/" .claude/gitflow/config.json
+
+  # Update source files
+  # csproj, package.json, etc.
+
+  git add -A
+  git commit -m "chore: bump version to $NEXT_VERSION for development"
+  git push origin develop
+
+  echo "✅ Version bumped to $NEXT_VERSION"
+fi
+```
+
+### 6. Clean Up Worktree
+
+```bash
+# Find worktree for this branch
+WORKTREE_PATH=$(git worktree list | grep "$BRANCH" | awk '{print $1}')
+
+if [ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ]; then
+  echo "Removing worktree: $WORKTREE_PATH"
+
+  # Make sure we're not in the worktree
+  cd $(git rev-parse --show-toplevel)
+
+  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || {
+    rm -rf "$WORKTREE_PATH"
+  }
+
+  git worktree prune
+  echo "✅ Worktree removed"
+fi
+```
+
+### 7. Delete Remote Branch
+
+```bash
+# Check if remote branch still exists
+REMOTE_EXISTS=$(git branch -r --list "origin/$BRANCH")
+
+if [ -n "$REMOTE_EXISTS" ]; then
+  echo "Deleting remote branch: $BRANCH"
+  git push origin --delete "$BRANCH" 2>/dev/null || {
+    echo "⚠️ Could not delete remote branch (may already be deleted by PR)"
+  }
+fi
+
+# Delete local branch
+git branch -D "$BRANCH" 2>/dev/null || echo "Local branch already deleted"
+```
+
+### 8. Archive Plan (if exists)
+
+```bash
+PLAN_FILE=$(ls .claude/gitflow/plans/*${BRANCH_NAME}*.md 2>/dev/null | head -1)
+
+if [ -f "$PLAN_FILE" ]; then
+  ARCHIVE_NAME="${PLAN_FILE%.md}_DONE_$(date +%Y%m%d-%H%M%S).md"
+  mv "$PLAN_FILE" "$ARCHIVE_NAME"
+  echo "✅ Plan archived: $ARCHIVE_NAME"
+fi
+```
+
+### 9. Summary
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║                    BRANCH FINALIZED                               ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Branch: {BRANCH}                                                 ║
+║  Type:   {BRANCH_TYPE}                                            ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Actions:                                                         ║
+{if release or hotfix}
+║  ✅ Tag created: {TAG_NAME}                                       ║
+║  ✅ Merged back to develop                                        ║
+{endif}
+{if release}
+║  ✅ Version bumped to {NEXT_VERSION}                              ║
+{endif}
+║  ✅ Worktree removed                                              ║
+║  ✅ Branch deleted (local + remote)                               ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Current branch: {main|develop}                                   ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Ready for next: /gitflow start feature <name>                    ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## ERROR HANDLING:
+
+| Error | Solution |
+|-------|----------|
+| Branch not merged | Merge first or force finish |
+| Tag exists | Overwrite or use different version |
+| Merge back conflicts | Resolve manually |
+| Worktree in use | Exit worktree first |
+
+---
+
+## SUCCESS CRITERIA:
+
+- Tag created (for release/hotfix)
+- Merged back to develop (for release/hotfix)
+- Worktree removed
+- Branch deleted
+- Plan archived
+
+## COMPLETION:
+
+GitFlow cycle complete. Ready for next feature/release/hotfix.