moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-lang-go/SKILL.md

@@ -1,22 +1,25 @@
 ---
-name: moai-lang-go
-description: Go 1.23+ development specialist covering Fiber, Gin, GORM, and concurrent programming patterns. Use when building high-performance microservices, CLI tools, or cloud-native applications.
-version: 1.0.0
-category: language
-tags: [go, golang, fiber, gin, concurrency, microservices]
-context7-libraries: [/gofiber/fiber, /gin-gonic/gin, /go-gorm/gorm]
-related-skills: [moai-lang-rust, moai-domain-backend]
-updated: 2025-12-07
-status: active
+name: "moai-lang-go"
+description: "Go 1.23+ development specialist covering Fiber, Gin, GORM, and concurrent programming patterns. Use when building high-performance microservices, CLI tools, or cloud-native applications."
+version: 1.1.0
+category: "language"
+modularized: false
+user-invocable: false
+tags: ['go', 'golang', 'fiber', 'gin', 'concurrency', 'microservices']
+context7-libraries: ['/gofiber/fiber', '/gin-gonic/gin', '/go-gorm/gorm']
+related-skills: ['moai-lang-rust', 'moai-domain-backend']
+updated: 2026-01-11
+status: "active"
 ---
 
 ## Quick Reference (30 seconds)
 
 Go 1.23+ Development Expert for high-performance backend systems and CLI applications.
 
-Auto-Triggers: `.go`, `go.mod`, `go.sum`, goroutines, channels, Fiber, Gin, GORM, Echo, Chi
+Auto-Triggers: Files with .go extension, go.mod, go.sum, goroutines, channels, Fiber, Gin, GORM, Echo, Chi
 
 Core Use Cases:
+
 - High-performance REST APIs and microservices
 - Concurrent and parallel processing systems
 - CLI tools and system utilities
@@ -24,31 +27,17 @@ Core Use Cases:
 
 Quick Patterns:
 
-Fiber API:
-```go
-app := fiber.New()
-app.Get("/api/users/:id", func(c fiber.Ctx) error {
-    return c.JSON(fiber.Map{"id": c.Params("id")})
-})
-app.Listen(":3000")
-```
-
-Gin API:
-```go
-r := gin.Default()
-r.GET("/api/users/:id", func(c *gin.Context) {
-    c.JSON(200, gin.H{"id": c.Param("id")})
-})
-r.Run(":3000")
-```
+Fiber API Pattern:
+
+Create app by calling fiber.New function. Define a get route at api/users/:id with handler function that takes fiber.Ctx and returns error. In the handler, call c.JSON with fiber.Map containing id from c.Params. Call app.Listen on port 3000.
+
+Gin API Pattern:
+
+Create r by calling gin.Default function. Define a GET route at api/users/:id with handler function taking gin.Context pointer. In handler, call c.JSON with status 200 and gin.H containing id from c.Param. Call r.Run on port 3000.
 
 Goroutine with Error Handling:
-```go
-g, ctx := errgroup.WithContext(context.Background())
-g.Go(func() error { return processUsers(ctx) })
-g.Go(func() error { return processOrders(ctx) })
-if err := g.Wait(); err != nil { log.Fatal(err) }
-```
+
+Create g and ctx by calling errgroup.WithContext with context.Background. Call g.Go with function that returns processUsers with ctx. Call g.Go with function that returns processOrders with ctx. If err from g.Wait is not nil, call log.Fatal with error.
 
 ---
 
@@ -57,222 +46,78 @@ if err := g.Wait(); err != nil { log.Fatal(err) }
 ### Go 1.23 Language Features
 
 New Features:
-- Range over integers: `for i := range 10 { fmt.Println(i) }`
-- Profile-Guided Optimization (PGO) 2.0
+
+- Range over integers using for i range 10 syntax and print i
+- Profile-Guided Optimization PGO 2.0
 - Improved generics with better type inference
 
-Generics:
-```go
-func Map[T, U any](slice []T, fn func(T) U) []U {
-    result := make([]U, len(slice))
-    for i, v := range slice { result[i] = fn(v) }
-    return result
-}
-```
-
-### Web Framework: Fiber v3
-
-```go
-app := fiber.New(fiber.Config{ErrorHandler: customErrorHandler, Prefork: true})
-app.Use(recover.New())
-app.Use(logger.New())
-app.Use(cors.New())
-
-api := app.Group("/api/v1")
-api.Get("/users", listUsers)
-api.Get("/users/:id", getUser)
-api.Post("/users", createUser)
-api.Put("/users/:id", updateUser)
-api.Delete("/users/:id", deleteUser)
-app.Listen(":3000")
-```
-
-### Web Framework: Gin
-
-```go
-r := gin.Default()
-r.Use(cors.Default())
-
-api := r.Group("/api/v1")
-api.GET("/users", listUsers)
-api.GET("/users/:id", getUser)
-api.POST("/users", createUser)
-r.Run(":3000")
-```
-
-Request Binding:
-```go
-type CreateUserRequest struct {
-    Name  string `json:"name" binding:"required,min=2"`
-    Email string `json:"email" binding:"required,email"`
-}
-
-func createUser(c *gin.Context) {
-    var req CreateUserRequest
-    if err := c.ShouldBindJSON(&req); err != nil {
-        c.JSON(400, gin.H{"error": err.Error()})
-        return
-    }
-    c.JSON(201, gin.H{"id": 1, "name": req.Name})
-}
-```
-
-### Web Framework: Echo
-
-```go
-e := echo.New()
-e.Use(middleware.Logger())
-e.Use(middleware.Recover())
-e.Use(middleware.CORS())
-
-api := e.Group("/api/v1")
-api.GET("/users", listUsers)
-api.POST("/users", createUser)
-e.Logger.Fatal(e.Start(":3000"))
-```
-
-### Web Framework: Chi
-
-```go
-r := chi.NewRouter()
-r.Use(middleware.Logger)
-r.Use(middleware.Recoverer)
-
-r.Route("/api/v1", func(r chi.Router) {
-    r.Route("/users", func(r chi.Router) {
-        r.Get("/", listUsers)
-        r.Post("/", createUser)
-        r.Get("/{id}", getUser)
-    })
-})
-http.ListenAndServe(":3000", r)
-```
-
-### ORM: GORM 1.25
+Generics Pattern:
+
+Create generic Map function with type parameters T and U as any. Accept slice of T and function from T to U. Create result slice of U with same length. Iterate range slice setting result elements to function applied to values. Return result.
+
+### Web Framework Fiber v3
+
+Create app with fiber.New passing fiber.Config with ErrorHandler and Prefork true. Use recover.New, logger.New, and cors.New middleware. Create api group at api/v1 path. Define routes for listUsers, getUser with id parameter, createUser, updateUser with id, and deleteUser with id. Call app.Listen on port 3000.
+
+### Web Framework Gin
+
+Create r with gin.Default. Use cors.Default middleware. Create api group at api/v1 path. Define GET for users calling listUsers, GET for users/:id calling getUser, POST for users calling createUser. Call r.Run on port 3000.
+
+Request Binding Pattern:
+
+Define CreateUserRequest struct with Name and Email fields. Add json tags and binding tags for required, min length 2, and required email validation. In createUser handler, declare req variable, call c.ShouldBindJSON with pointer. If error, call c.JSON with 400 status and error. Otherwise call c.JSON with 201 and response data.
+
+### Web Framework Echo
+
+Create e with echo.New. Use middleware.Logger, middleware.Recover, and middleware.CORS. Create api group at api/v1 path. Define GET for users and POST for users. Call e.Logger.Fatal with e.Start on port 3000.
+
+### Web Framework Chi
+
+Create r with chi.NewRouter. Use middleware.Logger and middleware.Recoverer. Call r.Route with api/v1 path and function. Inside, call r.Route with users path. Define Get for list, Post for create, Get with id parameter for single user. Call http.ListenAndServe on port 3000 with r.
+
+### ORM GORM 1.25
 
 Model Definition:
-```go
-type User struct {
-    gorm.Model
-    Name    string  `gorm:"uniqueIndex;not null"`
-    Email   string  `gorm:"uniqueIndex;not null"`
-    Posts   []Post  `gorm:"foreignKey:AuthorID"`
-}
-```
+
+Define User struct embedding gorm.Model. Add Name with uniqueIndex and not null tags, Email with uniqueIndex and not null, and Posts slice with foreignKey AuthorID tag.
 
 Query Patterns:
-```go
-db.Preload("Posts", func(db *gorm.DB) *gorm.DB {
-    return db.Order("created_at DESC").Limit(10)
-}).First(&user, 1)
-
-db.Transaction(func(tx *gorm.DB) error {
-    if err := tx.Create(&user).Error; err != nil { return err }
-    return tx.Create(&profile).Error
-})
-```
-
-### Type-Safe SQL: sqlc
-
-```yaml
-# sqlc.yaml
-version: "2"
-sql:
-  - engine: "postgresql"
-    queries: "query.sql"
-    schema: "schema.sql"
-    gen:
-      go:
-        package: "db"
-        out: "internal/db"
-        sql_package: "pgx/v5"
-```
-
-```sql
--- name: GetUser :one
-SELECT * FROM users WHERE id = $1;
-
--- name: CreateUser :one
-INSERT INTO users (name, email) VALUES ($1, $2) RETURNING *;
-```
+
+Call db.Preload with Posts and function that orders by created_at desc and limits to 10, then First with user and id 1. For transactions, call db.Transaction with function taking tx pointer. Inside, create user and profile, returning any errors.
+
+### Type-Safe SQL with sqlc
+
+Create sqlc.yaml with version 2, sql section with postgresql engine, queries and schema paths, and go generation settings for package name, output directory, and pgx v5 sql_package.
+
+In query.sql file, add name GetUser as one returning all columns where id matches parameter. Add name CreateUser as one inserting name and email values and returning all columns.
 
 ### Concurrency Patterns
 
-Errgroup:
-```go
-g, ctx := errgroup.WithContext(ctx)
-g.Go(func() error { users, err = fetchUsers(ctx); return err })
-g.Go(func() error { orders, err = fetchOrders(ctx); return err })
-if err := g.Wait(); err != nil { return nil, err }
-```
-
-Worker Pool:
-```go
-func workerPool(jobs <-chan Job, results chan<- Result, n int) {
-    var wg sync.WaitGroup
-    for i := 0; i < n; i++ {
-        wg.Add(1)
-        go func() {
-            defer wg.Done()
-            for job := range jobs { results <- processJob(job) }
-        }()
-    }
-    wg.Wait()
-    close(results)
-}
-```
+Errgroup Pattern:
+
+Create g and ctx with errgroup.WithContext. Call g.Go for fetchUsers that assigns to users variable. Call g.Go for fetchOrders that assigns to orders variable. If g.Wait returns error, return nil and error.
+
+Worker Pool Pattern:
+
+Define workerPool function taking jobs receive-only channel, results send-only channel, and n worker count. Create WaitGroup. Loop n times, incrementing WaitGroup and spawning goroutine that defers Done, ranges over jobs, and sends processJob result to results. Wait then close results.
 
 Context with Timeout:
-```go
-ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
-defer cancel()
-result, err := fetchData(ctx)
-if errors.Is(err, context.DeadlineExceeded) {
-    http.Error(w, "timeout", http.StatusGatewayTimeout)
-}
-```
+
+Create ctx and cancel with context.WithTimeout for 5 seconds. Defer cancel call. Call fetchData with ctx. If error is context.DeadlineExceeded, respond with timeout and StatusGatewayTimeout.
 
 ### Testing Patterns
 
 Table-Driven Tests:
-```go
-tests := []struct {
-    name    string
-    input   CreateUserInput
-    wantErr bool
-}{
-    {"valid", CreateUserInput{Name: "John"}, false},
-    {"empty", CreateUserInput{Name: ""}, true},
-}
-for _, tt := range tests {
-    t.Run(tt.name, func(t *testing.T) {
-        _, err := svc.Create(tt.input)
-        if tt.wantErr { require.Error(t, err) }
-    })
-}
-```
+
+Define tests slice with struct containing name string, input CreateUserInput, and wantErr bool. Add test cases for valid input and empty name. Range over tests calling t.Run with name and test function. Call service Create, check if wantErr is true and require.Error.
 
 HTTP Testing:
-```go
-app := fiber.New()
-app.Get("/users/:id", getUser)
-req := httptest.NewRequest("GET", "/users/1", nil)
-resp, _ := app.Test(req)
-assert.Equal(t, 200, resp.StatusCode)
-```
-
-### CLI: Cobra with Viper
-
-```go
-var rootCmd = &cobra.Command{Use: "myapp", Short: "Description"}
-
-func init() {
-    rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file")
-    viper.BindPFlag("config", rootCmd.PersistentFlags().Lookup("config"))
-    viper.SetEnvPrefix("MYAPP")
-    viper.AutomaticEnv()
-}
-```
+
+Create app with fiber.New. Add GET route for users/:id calling getUser. Create request with httptest.NewRequest for GET at users/1. Call app.Test with request to get response. Assert 200 status code.
+
+### CLI Cobra with Viper
+
+Define rootCmd as cobra.Command pointer with Use and Short fields. In init function, add PersistentFlags StringVar for cfgFile. Call viper.BindPFlag with config and lookup. Set viper.SetEnvPrefix to MYAPP and call viper.AutomaticEnv.
 
 ---
 
@@ -281,96 +126,72 @@ func init() {
 ### Performance Optimization
 
 PGO Build:
-```bash
-GODEBUG=pgo=1 ./myapp -cpuprofile=default.pgo
-go build -pgo=default.pgo -o myapp
-```
+
+Run application with GODEBUG pgo enabled and cpuprofile output. Build with go build using pgo flag pointing to profile file.
 
 Object Pooling:
-```go
-var bufferPool = sync.Pool{
-    New: func() interface{} { return make([]byte, 4096) },
-}
-buf := bufferPool.Get().([]byte)
-defer bufferPool.Put(buf)
-```
-
-### Container Deployment (10-20MB)
-
-```dockerfile
-FROM golang:1.23-alpine AS builder
-WORKDIR /app
-COPY go.mod go.sum ./
-RUN go mod download
-COPY . .
-RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o main .
-
-FROM scratch
-COPY --from=builder /app/main /main
-ENTRYPOINT ["/main"]
-```
+
+Create bufferPool as sync.Pool with New function returning 4096 byte slice. Get buffer with type assertion, defer Put to return to pool.
+
+### Container Deployment 10-20MB
+
+Multi-stage Dockerfile: First stage uses golang:1.23-alpine as builder, sets WORKDIR, copies go.mod and go.sum, runs go mod download, copies source, builds with CGO_ENABLED 0 and ldflags for stripped binary. Second stage uses scratch, copies binary, sets ENTRYPOINT.
 
 ### Graceful Shutdown
 
-```go
-go func() { app.Listen(":3000") }()
-quit := make(chan os.Signal, 1)
-signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
-<-quit
-app.Shutdown()
-```
+Spawn goroutine calling app.Listen. Create quit channel for os.Signal with buffer 1. Call signal.Notify for SIGINT and SIGTERM. Receive from quit then call app.Shutdown.
 
 ---
 
 ## Context7 Libraries
 
-```
-/golang/go        - Go language and stdlib
-/gofiber/fiber    - Fiber web framework
-/gin-gonic/gin    - Gin web framework
-/labstack/echo    - Echo web framework
-/go-chi/chi       - Chi router
-/go-gorm/gorm     - GORM ORM
-/sqlc-dev/sqlc    - Type-safe SQL
-/jackc/pgx        - PostgreSQL driver
-/spf13/cobra      - CLI framework
-/spf13/viper      - Configuration
-/stretchr/testify - Testing toolkit
-```
+- golang/go for Go language and stdlib
+- gofiber/fiber for Fiber web framework
+- gin-gonic/gin for Gin web framework
+- labstack/echo for Echo web framework
+- go-chi/chi for Chi router
+- go-gorm/gorm for GORM ORM
+- sqlc-dev/sqlc for type-safe SQL
+- jackc/pgx for PostgreSQL driver
+- spf13/cobra for CLI framework
+- spf13/viper for configuration
+- stretchr/testify for testing toolkit
 
 ---
 
 ## Works Well With
 
-- `moai-domain-backend` - REST API architecture and microservices
-- `moai-lang-rust` - Systems programming companion
-- `moai-quality-security` - Security hardening
-- `moai-essentials-debug` - Performance profiling
-- `moai-workflow-tdd` - Test-driven development
+- moai-domain-backend for REST API architecture and microservices
+- moai-lang-rust for systems programming companion
+- moai-quality-security for security hardening
+- moai-essentials-debug for performance profiling
+- moai-workflow-tdd for test-driven development
 
 ---
 
 ## Troubleshooting
 
 Common Issues:
-- Module errors: `go mod tidy && go mod verify`
-- Version check: `go version && go env GOVERSION`
-- Build issues: `go clean -cache && go build -v`
+
+- Module errors: Run go mod tidy and go mod verify
+- Version check: Run go version and go env GOVERSION
+- Build issues: Run go clean -cache and go build -v
 
 Performance Diagnostics:
-- CPU profiling: `go test -cpuprofile=cpu.prof -bench=.`
-- Memory profiling: `go test -memprofile=mem.prof -bench=.`
-- Race detection: `go test -race ./...`
+
+- CPU profiling: Run go test -cpuprofile cpu.prof -bench .
+- Memory profiling: Run go test -memprofile mem.prof -bench .
+- Race detection: Run go test -race ./...
 
 ---
 
 ## Additional Resources
 
-See [reference.md](reference.md) for complete framework reference, advanced patterns, and Context7 library mappings.
+See reference.md for complete framework reference, advanced patterns, and Context7 library mappings.
 
-See [examples.md](examples.md) for production-ready code including REST APIs, CLI tools, and deployment configurations.
+See examples.md for production-ready code including REST APIs, CLI tools, and deployment configurations.
 
 ---
 
-Last Updated: 2025-12-07
-Version: 1.0.0
+Last Updated: 2026-01-11
+Version: 1.1.0