autoworkflow 3.1.5 → 3.5.0

package/.claude/skills/gin.md

@@ -0,0 +1,342 @@
+# Gin Framework Skill
+
+## Application Setup
+\`\`\`go
+package main
+
+import (
+    "log"
+    "net/http"
+    "os"
+
+    "github.com/gin-gonic/gin"
+)
+
+func main() {
+    // Set mode from environment
+    if os.Getenv("GIN_MODE") == "release" {
+        gin.SetMode(gin.ReleaseMode)
+    }
+
+    r := gin.New()
+
+    // Global middleware
+    r.Use(gin.Logger())
+    r.Use(gin.Recovery())
+    r.Use(CORSMiddleware())
+
+    // Health check
+    r.GET("/health", func(c *gin.Context) {
+        c.JSON(http.StatusOK, gin.H{"status": "ok"})
+    })
+
+    // API routes
+    setupRoutes(r)
+
+    log.Fatal(r.Run(":8080"))
+}
+\`\`\`
+
+## Route Groups and Handlers
+\`\`\`go
+func setupRoutes(r *gin.Engine) {
+    // Public routes
+    public := r.Group("/api/v1")
+    {
+        public.POST("/auth/login", loginHandler)
+        public.POST("/auth/register", registerHandler)
+    }
+
+    // Protected routes
+    protected := r.Group("/api/v1")
+    protected.Use(AuthMiddleware())
+    {
+        // Users
+        users := protected.Group("/users")
+        {
+            users.GET("", listUsersHandler)
+            users.GET("/:id", getUserHandler)
+            users.PUT("/:id", updateUserHandler)
+            users.DELETE("/:id", deleteUserHandler)
+        }
+
+        // Posts (with additional middleware)
+        posts := protected.Group("/posts")
+        posts.Use(RateLimitMiddleware())
+        {
+            posts.GET("", listPostsHandler)
+            posts.POST("", createPostHandler)
+            posts.GET("/:id", getPostHandler)
+        }
+    }
+}
+\`\`\`
+
+## Request Binding and Validation
+\`\`\`go
+// Request DTOs with validation tags
+type CreateUserRequest struct {
+    Email    string \`json:"email" binding:"required,email"\`
+    Name     string \`json:"name" binding:"required,min=2,max=100"\`
+    Password string \`json:"password" binding:"required,min=8"\`
+    Age      int    \`json:"age" binding:"omitempty,gte=0,lte=150"\`
+}
+
+type UpdateUserRequest struct {
+    Name *string \`json:"name" binding:"omitempty,min=2,max=100"\`
+    Age  *int    \`json:"age" binding:"omitempty,gte=0,lte=150"\`
+}
+
+type PaginationQuery struct {
+    Page    int    \`form:"page" binding:"omitempty,min=1"\`
+    PerPage int    \`form:"per_page" binding:"omitempty,min=1,max=100"\`
+    Sort    string \`form:"sort" binding:"omitempty,oneof=asc desc"\`
+}
+
+func createUserHandler(c *gin.Context) {
+    var req CreateUserRequest
+    if err := c.ShouldBindJSON(&req); err != nil {
+        c.JSON(http.StatusBadRequest, gin.H{
+            "error":   "validation_error",
+            "details": formatValidationErrors(err),
+        })
+        return
+    }
+
+    user, err := userService.Create(c.Request.Context(), req)
+    if err != nil {
+        handleError(c, err)
+        return
+    }
+
+    c.JSON(http.StatusCreated, user)
+}
+
+func listUsersHandler(c *gin.Context) {
+    var query PaginationQuery
+    if err := c.ShouldBindQuery(&query); err != nil {
+        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+        return
+    }
+
+    // Set defaults
+    if query.Page == 0 {
+        query.Page = 1
+    }
+    if query.PerPage == 0 {
+        query.PerPage = 20
+    }
+
+    users, total, err := userService.List(c.Request.Context(), query)
+    if err != nil {
+        handleError(c, err)
+        return
+    }
+
+    c.JSON(http.StatusOK, gin.H{
+        "data":     users,
+        "total":    total,
+        "page":     query.Page,
+        "per_page": query.PerPage,
+    })
+}
+\`\`\`
+
+## Custom Middleware
+\`\`\`go
+// CORS Middleware
+func CORSMiddleware() gin.HandlerFunc {
+    return func(c *gin.Context) {
+        c.Header("Access-Control-Allow-Origin", "*")
+        c.Header("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS")
+        c.Header("Access-Control-Allow-Headers", "Authorization,Content-Type")
+
+        if c.Request.Method == "OPTIONS" {
+            c.AbortWithStatus(http.StatusNoContent)
+            return
+        }
+
+        c.Next()
+    }
+}
+
+// Auth Middleware with JWT
+func AuthMiddleware() gin.HandlerFunc {
+    return func(c *gin.Context) {
+        authHeader := c.GetHeader("Authorization")
+        if authHeader == "" {
+            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+                "error": "missing authorization header",
+            })
+            return
+        }
+
+        tokenString := strings.TrimPrefix(authHeader, "Bearer ")
+        claims, err := validateToken(tokenString)
+        if err != nil {
+            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+                "error": "invalid token",
+            })
+            return
+        }
+
+        // Store user info in context
+        c.Set("userID", claims.UserID)
+        c.Set("userRole", claims.Role)
+        c.Next()
+    }
+}
+
+// Rate Limiting Middleware
+func RateLimitMiddleware() gin.HandlerFunc {
+    limiter := rate.NewLimiter(rate.Every(time.Second), 10)
+
+    return func(c *gin.Context) {
+        if !limiter.Allow() {
+            c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
+                "error": "rate limit exceeded",
+            })
+            return
+        }
+        c.Next()
+    }
+}
+
+// Request ID Middleware
+func RequestIDMiddleware() gin.HandlerFunc {
+    return func(c *gin.Context) {
+        requestID := c.GetHeader("X-Request-ID")
+        if requestID == "" {
+            requestID = uuid.New().String()
+        }
+        c.Set("requestID", requestID)
+        c.Header("X-Request-ID", requestID)
+        c.Next()
+    }
+}
+\`\`\`
+
+## Error Handling
+\`\`\`go
+// Centralized error handling
+func handleError(c *gin.Context, err error) {
+    switch {
+    case errors.Is(err, ErrNotFound):
+        c.JSON(http.StatusNotFound, gin.H{"error": "resource not found"})
+    case errors.Is(err, ErrUnauthorized):
+        c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"})
+    case errors.Is(err, ErrForbidden):
+        c.JSON(http.StatusForbidden, gin.H{"error": "forbidden"})
+    case errors.Is(err, ErrConflict):
+        c.JSON(http.StatusConflict, gin.H{"error": "resource already exists"})
+    default:
+        log.Printf("internal error: %v", err)
+        c.JSON(http.StatusInternalServerError, gin.H{"error": "internal server error"})
+    }
+}
+
+// Format validation errors
+func formatValidationErrors(err error) map[string]string {
+    errors := make(map[string]string)
+
+    var ve validator.ValidationErrors
+    if stderrors.As(err, &ve) {
+        for _, e := range ve {
+            field := strings.ToLower(e.Field())
+            switch e.Tag() {
+            case "required":
+                errors[field] = "this field is required"
+            case "email":
+                errors[field] = "invalid email format"
+            case "min":
+                errors[field] = fmt.Sprintf("must be at least %s characters", e.Param())
+            case "max":
+                errors[field] = fmt.Sprintf("must be at most %s characters", e.Param())
+            default:
+                errors[field] = "invalid value"
+            }
+        }
+    }
+
+    return errors
+}
+\`\`\`
+
+## Testing
+\`\`\`go
+package handler_test
+
+import (
+    "bytes"
+    "encoding/json"
+    "net/http"
+    "net/http/httptest"
+    "testing"
+
+    "github.com/gin-gonic/gin"
+    "github.com/stretchr/testify/assert"
+)
+
+func setupTestRouter() *gin.Engine {
+    gin.SetMode(gin.TestMode)
+    r := gin.New()
+    setupRoutes(r)
+    return r
+}
+
+func TestCreateUser(t *testing.T) {
+    router := setupTestRouter()
+
+    tests := []struct {
+        name       string
+        body       map[string]interface{}
+        wantStatus int
+    }{
+        {
+            name: "valid user",
+            body: map[string]interface{}{
+                "email":    "test@example.com",
+                "name":     "Test User",
+                "password": "password123",
+            },
+            wantStatus: http.StatusCreated,
+        },
+        {
+            name: "missing email",
+            body: map[string]interface{}{
+                "name":     "Test User",
+                "password": "password123",
+            },
+            wantStatus: http.StatusBadRequest,
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            body, _ := json.Marshal(tt.body)
+            req := httptest.NewRequest("POST", "/api/v1/users", bytes.NewBuffer(body))
+            req.Header.Set("Content-Type", "application/json")
+
+            w := httptest.NewRecorder()
+            router.ServeHTTP(w, req)
+
+            assert.Equal(t, tt.wantStatus, w.Code)
+        })
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Use route groups for organization
+- Use \`ShouldBindJSON\` (returns error) not \`BindJSON\` (aborts on error)
+- Use context from \`c.Request.Context()\` for database calls
+- Set up proper validation tags on request structs
+- Create centralized error handling
+- Use middleware for cross-cutting concerns
+
+## ❌ DON'T
+- Don't use \`c.Abort()\` without setting response
+- Don't ignore validation errors
+- Don't store sensitive data in \`gin.Context\` (use request context)
+- Don't forget to call \`c.Next()\` in middleware when continuing chain
+- Don't use global variables for dependencies

package/.claude/skills/git.md

@@ -0,0 +1,116 @@
+# Git Skill
+
+## Conventional Commits
+\`\`\`
+<type>(<scope>): <description>
+
+[optional body]
+
+[optional footer(s)]
+\`\`\`
+
+**Types:**
+- \`feat\`: New feature (MINOR version bump)
+- \`fix\`: Bug fix (PATCH version bump)
+- \`docs\`: Documentation only
+- \`style\`: Formatting, no code change
+- \`refactor\`: Code change, no feature/fix
+- \`test\`: Adding/updating tests
+- \`chore\`: Build, deps, configs
+
+**Examples:**
+\`\`\`bash
+feat(auth): add password reset flow
+fix(api): handle null response from user endpoint
+docs(readme): update installation steps
+refactor(utils): extract date formatting helpers
+\`\`\`
+
+## Branch Strategy
+\`\`\`
+main          # Production-ready
+├── develop   # Integration branch
+    ├── feature/auth-login    # New features
+    ├── fix/user-loading      # Bug fixes
+    └── refactor/api-cleanup  # Refactoring
+\`\`\`
+
+## Git Stash Workflow
+\`\`\`bash
+# Save work in progress
+git stash push -m "WIP: feature description"
+
+# List stashes
+git stash list
+
+# Apply and keep stash
+git stash apply stash@{0}
+
+# Apply and remove stash
+git stash pop
+
+# Create branch from stash
+git stash branch new-branch stash@{0}
+\`\`\`
+
+## Interactive Rebase
+\`\`\`bash
+# Rebase last 3 commits
+git rebase -i HEAD~3
+
+# Rebase onto main
+git rebase -i main
+
+# Commands in interactive mode:
+# pick   = use commit
+# reword = edit commit message
+# squash = combine with previous commit
+# fixup  = squash but discard message
+# drop   = remove commit
+\`\`\`
+
+## Merge Conflict Resolution
+\`\`\`bash
+# 1. Start merge/rebase
+git merge feature-branch
+
+# 2. View conflicts
+git status
+
+# 3. After resolving in editor
+git add <resolved-files>
+git merge --continue
+# OR for rebase:
+git rebase --continue
+
+# Abort if needed
+git merge --abort
+git rebase --abort
+\`\`\`
+
+## Pre-commit Hooks (with Husky)
+\`\`\`bash
+# Install husky
+npx husky init
+
+# Add pre-commit hook
+echo "npm run lint && npm run test" > .husky/pre-commit
+
+# Add commit-msg hook for conventional commits
+echo 'npx commitlint --edit "$1"' > .husky/commit-msg
+\`\`\`
+
+## ❌ DON'T
+- Commit secrets or .env files
+- Force push to main/develop
+- Commit large generated files
+- Write vague commit messages
+- Rebase public/shared branches
+
+## ✅ DO
+- Commit often, push regularly
+- Write descriptive commit messages
+- Use .gitignore properly
+- Review diff before committing
+- Use stash for quick context switches
+- Squash WIP commits before merging