javi-forge 1.2.0 → 1.4.0

package/ai-config/skills/backend/go-backend/SKILL.md

@@ -1,457 +0,0 @@
----
-name: go-backend
-description: >
-  Go backend development patterns with Chi router, PostgreSQL/pgx, JWT auth, and clean architecture.
-  Trigger: Go API, Chi router, pgx, PostgreSQL, Go backend, REST API Go, Go service
-tools:
-  - Read
-  - Write
-  - Bash
-  - Grep
-metadata:
-  author: plataforma-industrial
-  version: "2.0"
-  tags: [go, backend, chi, postgresql, jwt, api, clean-architecture]
-  updated: "2026-02"
----
-
-# Go Backend Development
-
-Patterns for building production Go backends with Chi, PostgreSQL, and clean architecture.
-
-## Stack
-
-```yaml
-Go: 1.22+
-Chi: 5.0.12
-pgx: v5.5.5
-JWT: golang-jwt/jwt/v5
-Validator: go-playground/validator/v10
-```
-
-## Project Structure
-
-```
-apps/api/
-├── cmd/
-│   └── server/
-│       └── main.go
-├── internal/
-│   ├── config/
-│   │   └── config.go
-│   ├── server/
-│   │   ├── server.go
-│   │   └── routes.go
-│   ├── middleware/
-│   │   ├── auth.go
-│   │   ├── logging.go
-│   │   └── recovery.go
-│   ├── domain/
-│   │   └── model.go
-│   ├── repository/
-│   │   └── postgres.go
-│   ├── service/
-│   │   └── service.go
-│   └── handler/
-│       └── handler.go
-├── pkg/
-│   ├── logger/
-│   └── response/
-├── go.mod
-└── Dockerfile
-```
-
-## Model Pattern
-
-```go
-package domain
-
-import (
-    "time"
-    "github.com/google/uuid"
-)
-
-type Status string
-
-const (
-    StatusActive   Status = "active"
-    StatusInactive Status = "inactive"
-)
-
-type Entity struct {
-    ID        uuid.UUID `json:"id" db:"id"`
-    Name      string    `json:"name" db:"name" validate:"required,min=3,max=100"`
-    Status    Status    `json:"status" db:"status" validate:"required,oneof=active inactive"`
-    CreatedAt time.Time `json:"created_at" db:"created_at"`
-    UpdatedAt time.Time `json:"updated_at" db:"updated_at"`
-}
-
-type CreateRequest struct {
-    Name   string `json:"name" validate:"required,min=3,max=100"`
-    Status Status `json:"status" validate:"required,oneof=active inactive"`
-}
-
-type UpdateRequest struct {
-    Name   *string `json:"name,omitempty" validate:"omitempty,min=3,max=100"`
-    Status *Status `json:"status,omitempty" validate:"omitempty,oneof=active inactive"`
-}
-```
-
-## Repository Pattern
-
-```go
-package repository
-
-import (
-    "context"
-    "errors"
-    "fmt"
-
-    "github.com/google/uuid"
-    "github.com/jackc/pgx/v5"
-    "github.com/jackc/pgx/v5/pgxpool"
-)
-
-var (
-    ErrNotFound      = errors.New("entity not found")
-    ErrDuplicateName = errors.New("name already exists")
-)
-
-type Repository interface {
-    Create(ctx context.Context, entity *Entity) error
-    GetByID(ctx context.Context, id uuid.UUID) (*Entity, error)
-    GetAll(ctx context.Context) ([]Entity, error)
-    Update(ctx context.Context, entity *Entity) error
-    Delete(ctx context.Context, id uuid.UUID) error
-}
-
-type PostgresRepository struct {
-    db *pgxpool.Pool
-}
-
-func NewPostgresRepository(db *pgxpool.Pool) *PostgresRepository {
-    return &PostgresRepository{db: db}
-}
-
-func (r *PostgresRepository) GetByID(ctx context.Context, id uuid.UUID) (*Entity, error) {
-    query := `SELECT id, name, status, created_at, updated_at FROM entities WHERE id = $1`
-
-    var entity Entity
-    err := r.db.QueryRow(ctx, query, id).Scan(
-        &entity.ID, &entity.Name, &entity.Status,
-        &entity.CreatedAt, &entity.UpdatedAt,
-    )
-
-    if errors.Is(err, pgx.ErrNoRows) {
-        return nil, ErrNotFound
-    }
-    if err != nil {
-        return nil, fmt.Errorf("get entity: %w", err)
-    }
-
-    return &entity, nil
-}
-```
-
-## Service Pattern
-
-```go
-package service
-
-import (
-    "context"
-    "log/slog"
-    "time"
-
-    "github.com/google/uuid"
-)
-
-type Service struct {
-    repo   Repository
-    logger *slog.Logger
-}
-
-func NewService(repo Repository, logger *slog.Logger) *Service {
-    return &Service{repo: repo, logger: logger}
-}
-
-func (s *Service) Create(ctx context.Context, req CreateRequest) (*Entity, error) {
-    entity := &Entity{
-        ID:        uuid.New(),
-        Name:      req.Name,
-        Status:    req.Status,
-        CreatedAt: time.Now().UTC(),
-        UpdatedAt: time.Now().UTC(),
-    }
-
-    if err := s.repo.Create(ctx, entity); err != nil {
-        s.logger.Error("failed to create entity", "error", err)
-        return nil, err
-    }
-
-    s.logger.Info("entity created", "id", entity.ID)
-    return entity, nil
-}
-```
-
-## Handler Pattern
-
-```go
-package handler
-
-import (
-    "encoding/json"
-    "errors"
-    "net/http"
-
-    "github.com/go-chi/chi/v5"
-    "github.com/go-playground/validator/v10"
-    "github.com/google/uuid"
-)
-
-type Handler struct {
-    service   *Service
-    validator *validator.Validate
-}
-
-func NewHandler(service *Service) *Handler {
-    return &Handler{
-        service:   service,
-        validator: validator.New(),
-    }
-}
-
-func (h *Handler) RegisterRoutes(r chi.Router) {
-    r.Route("/entities", func(r chi.Router) {
-        r.Get("/", h.GetAll)
-        r.Post("/", h.Create)
-        r.Route("/{id}", func(r chi.Router) {
-            r.Get("/", h.GetByID)
-            r.Put("/", h.Update)
-            r.Delete("/", h.Delete)
-        })
-    })
-}
-
-func (h *Handler) GetByID(w http.ResponseWriter, r *http.Request) {
-    id, err := uuid.Parse(chi.URLParam(r, "id"))
-    if err != nil {
-        respondError(w, http.StatusBadRequest, "invalid id")
-        return
-    }
-
-    entity, err := h.service.GetByID(r.Context(), id)
-    if errors.Is(err, ErrNotFound) {
-        respondError(w, http.StatusNotFound, "entity not found")
-        return
-    }
-    if err != nil {
-        respondError(w, http.StatusInternalServerError, "internal error")
-        return
-    }
-
-    respondJSON(w, http.StatusOK, entity)
-}
-```
-
-## PostgreSQL Connection
-
-```go
-package database
-
-import (
-    "context"
-    "fmt"
-    "time"
-
-    "github.com/jackc/pgx/v5/pgxpool"
-)
-
-type Config struct {
-    Host     string
-    Port     int
-    User     string
-    Password string
-    DBName   string
-    SSLMode  string
-    MaxConns int32
-}
-
-func NewPool(ctx context.Context, cfg Config) (*pgxpool.Pool, error) {
-    dsn := fmt.Sprintf(
-        "postgres://%s:%s@%s:%d/%s?sslmode=%s",
-        cfg.User, cfg.Password, cfg.Host, cfg.Port, cfg.DBName, cfg.SSLMode,
-    )
-
-    poolConfig, err := pgxpool.ParseConfig(dsn)
-    if err != nil {
-        return nil, fmt.Errorf("parse config: %w", err)
-    }
-
-    poolConfig.MaxConns = cfg.MaxConns
-    poolConfig.MaxConnLifetime = 1 * time.Hour
-    poolConfig.MaxConnIdleTime = 30 * time.Minute
-
-    pool, err := pgxpool.NewWithConfig(ctx, poolConfig)
-    if err != nil {
-        return nil, fmt.Errorf("create pool: %w", err)
-    }
-
-    if err := pool.Ping(ctx); err != nil {
-        pool.Close()
-        return nil, fmt.Errorf("ping: %w", err)
-    }
-
-    return pool, nil
-}
-```
-
-## JWT Authentication
-
-```go
-package auth
-
-import (
-    "errors"
-    "time"
-
-    "github.com/golang-jwt/jwt/v5"
-    "github.com/google/uuid"
-)
-
-var (
-    ErrInvalidToken = errors.New("invalid token")
-    ErrExpiredToken = errors.New("token expired")
-)
-
-type Claims struct {
-    UserID uuid.UUID `json:"sub"`
-    Email  string    `json:"email"`
-    Role   string    `json:"role"`
-    jwt.RegisteredClaims
-}
-
-type JWTService struct {
-    secretKey    []byte
-    accessExpiry time.Duration
-}
-
-func NewJWTService(secret string, expiry time.Duration) *JWTService {
-    return &JWTService{
-        secretKey:    []byte(secret),
-        accessExpiry: expiry,
-    }
-}
-
-func (s *JWTService) GenerateToken(userID uuid.UUID, email, role string) (string, error) {
-    claims := Claims{
-        UserID: userID,
-        Email:  email,
-        Role:   role,
-        RegisteredClaims: jwt.RegisteredClaims{
-            ExpiresAt: jwt.NewNumericDate(time.Now().Add(s.accessExpiry)),
-            IssuedAt:  jwt.NewNumericDate(time.Now()),
-        },
-    }
-
-    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
-    return token.SignedString(s.secretKey)
-}
-
-func (s *JWTService) ValidateToken(tokenString string) (*Claims, error) {
-    token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
-        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
-            return nil, ErrInvalidToken
-        }
-        return s.secretKey, nil
-    })
-
-    if err != nil {
-        if errors.Is(err, jwt.ErrTokenExpired) {
-            return nil, ErrExpiredToken
-        }
-        return nil, ErrInvalidToken
-    }
-
-    claims, ok := token.Claims.(*Claims)
-    if !ok || !token.Valid {
-        return nil, ErrInvalidToken
-    }
-
-    return claims, nil
-}
-```
-
-## Response Helpers
-
-```go
-package response
-
-import (
-    "encoding/json"
-    "net/http"
-)
-
-type ErrorResponse struct {
-    Error   string            `json:"error"`
-    Details map[string]string `json:"details,omitempty"`
-}
-
-func JSON(w http.ResponseWriter, status int, data any) {
-    w.Header().Set("Content-Type", "application/json")
-    w.WriteHeader(status)
-    if data != nil && status != http.StatusNoContent {
-        json.NewEncoder(w).Encode(data)
-    }
-}
-
-func Error(w http.ResponseWriter, status int, message string) {
-    JSON(w, status, ErrorResponse{Error: message})
-}
-```
-
-## Testing
-
-```go
-package service_test
-
-import (
-    "context"
-    "testing"
-
-    "github.com/stretchr/testify/assert"
-    "github.com/stretchr/testify/require"
-)
-
-func TestService_Create(t *testing.T) {
-    repo := NewMockRepository()
-    svc := NewService(repo, slog.Default())
-
-    req := CreateRequest{
-        Name:   "Test Entity",
-        Status: StatusActive,
-    }
-
-    entity, err := svc.Create(context.Background(), req)
-
-    require.NoError(t, err)
-    assert.Equal(t, "Test Entity", entity.Name)
-    assert.NotEmpty(t, entity.ID)
-}
-```
-
-## Conventions
-
-- **Packages:** lowercase, singular (`user`, not `users`)
-- **Files:** snake_case (`user_repository.go`)
-- **Error handling:** Always wrap with context `fmt.Errorf("operation: %w", err)`
-- **Context:** Always first parameter
-- **Validation:** Use `go-playground/validator` tags
-
-## Related Skills
-
-- `chi-router`: Chi HTTP routing patterns
-- `pgx-postgres`: PostgreSQL with pgx driver
-- `jwt-auth`: Authentication middleware
-- `redis-cache`: Caching strategies
-- `docker-containers`: Containerization

package/ai-config/skills/backend/gradle-multimodule/SKILL.md

@@ -1,274 +0,0 @@
----
-name: gradle-multimodule
-description: >
-  Gradle 9.x multi-module configuration for APiGen. Build, dependencies, publishing.
-  Trigger: gradle, build.gradle, multi-module, dependencies, publishing
-tools:
-  - Read
-  - Write
-  - Edit
-  - Bash
-  - Grep
-metadata:
-  author: apigen-team
-  version: "1.0"
-  tags: [gradle, build, multimodule]
-  scope: ["*.gradle", "*.gradle.kts", "settings.gradle"]
----
-
-# Gradle Multi-Module (APiGen)
-
-## Estructura
-
-```
-apigen/
-├── build.gradle              # Root: plugins, common config
-├── settings.gradle           # Module includes
-├── gradle.properties         # Versions, properties
-├── apigen-bom/build.gradle   # BOM module
-├── apigen-core/build.gradle  # Library module
-├── apigen-security/          # Library module
-├── apigen-codegen/           # Utility module
-├── apigen-server/            # Application module
-└── ...
-```
-
-## Root build.gradle
-
-```groovy
-plugins {
-    id 'java'
-    id 'com.diffplug.spotless' version '7.1.0'
-    id 'org.sonarqube' version '6.1.0.5360'
-    id 'io.spring.dependency-management' version '1.1.7' apply false
-    id 'org.springframework.boot' version '4.0.0' apply false
-}
-
-// Common config for all subprojects
-subprojects {
-    if (name != 'apigen-bom') {
-        apply plugin: 'java'
-        apply plugin: 'io.spring.dependency-management'
-
-        java {
-            toolchain {
-                languageVersion = JavaLanguageVersion.of(25)
-            }
-        }
-
-        repositories {
-            mavenCentral()
-        }
-
-        dependencyManagement {
-            imports {
-                mavenBom "org.springframework.boot:spring-boot-dependencies:4.0.0"
-            }
-        }
-
-        // Spotless
-        spotless {
-            java {
-                target 'src/**/*.java'
-                googleJavaFormat('1.33.0').aosp().reflowLongStrings()
-            }
-        }
-    }
-}
-```
-
-## Module: apigen-bom
-
-```groovy
-plugins {
-    id 'java-platform'
-    id 'maven-publish'
-}
-
-javaPlatform {
-    allowDependencies()
-}
-
-dependencies {
-    api platform("org.springframework.boot:spring-boot-dependencies:4.0.0")
-
-    constraints {
-        api "com.jnzader:apigen-core:${version}"
-        api "com.jnzader:apigen-security:${version}"
-        api "com.jnzader:apigen-graphql:${version}"
-        api "com.jnzader:apigen-grpc:${version}"
-        api "com.jnzader:apigen-gateway:${version}"
-
-        // Third-party
-        api "io.jsonwebtoken:jjwt-api:0.13.0"
-        api "com.bucket4j:bucket4j-core:8.16.0"
-    }
-}
-```
-
-## Module: Library (apigen-core)
-
-```groovy
-plugins {
-    id 'java-library'
-    id 'maven-publish'
-}
-
-dependencies {
-    // API dependencies (transitivas)
-    api 'org.springframework.boot:spring-boot-starter-data-jpa'
-    api 'org.springframework.boot:spring-boot-starter-validation'
-    api 'org.springframework.boot:spring-boot-starter-hateoas'
-
-    // Implementation (no transitivas)
-    implementation 'com.github.ben-manes.caffeine:caffeine'
-    implementation 'org.mapstruct:mapstruct:1.6.3'
-
-    // Annotation processors
-    annotationProcessor 'org.mapstruct:mapstruct-processor:1.6.3'
-    annotationProcessor 'org.projectlombok:lombok'
-
-    // Test
-    testImplementation 'org.springframework.boot:spring-boot-starter-test'
-    testImplementation 'org.testcontainers:postgresql'
-}
-```
-
-## Module: Application (apigen-server)
-
-```groovy
-plugins {
-    id 'org.springframework.boot'
-}
-
-dependencies {
-    implementation project(':apigen-core')
-    implementation project(':apigen-security')
-    implementation project(':apigen-codegen')
-
-    implementation 'org.springframework.boot:spring-boot-starter-web'
-
-    // Runtime only
-    runtimeOnly 'org.postgresql:postgresql'
-
-    // Test
-    testImplementation 'org.springframework.boot:spring-boot-starter-test'
-}
-
-bootJar {
-    archiveFileName = "apigen-server.jar"
-}
-```
-
-## Comandos Comunes
-
-```bash
-# Formatear código
-./gradlew spotlessApply
-
-# Build específico
-./gradlew :apigen-core:build
-
-# Test específico
-./gradlew :apigen-core:test
-
-# Build todo
-./gradlew buildAll
-
-# Test todo
-./gradlew testAll
-
-# Publish local
-./gradlew publishToMavenLocal
-
-# Dependencias de un módulo
-./gradlew :apigen-core:dependencies
-
-# Ejecutar servidor
-./gradlew :apigen-server:bootRun
-```
-
-## Custom Tasks (root build.gradle)
-
-```groovy
-tasks.register('buildAll') {
-    group = 'build'
-    description = 'Build all modules'
-    dependsOn subprojects.collect { "${it.path}:build" }
-}
-
-tasks.register('testAll') {
-    group = 'verification'
-    description = 'Test all modules'
-    dependsOn subprojects.collect { "${it.path}:test" }
-}
-
-tasks.register('publishAll') {
-    group = 'publishing'
-    description = 'Publish all modules to Maven Local'
-    dependsOn subprojects.findAll { it.plugins.hasPlugin('maven-publish') }
-        .collect { "${it.path}:publishToMavenLocal" }
-}
-```
-
-## Testing Configuration
-
-```groovy
-// En root o cada módulo
-test {
-    useJUnitPlatform()
-
-    testLogging {
-        events "passed", "skipped", "failed"
-    }
-
-    // Paralelismo
-    maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1
-}
-
-// Separar IT tests
-tasks.register('integrationTest', Test) {
-    description = 'Run integration tests'
-    group = 'verification'
-
-    testClassesDirs = sourceSets.test.output.classesDirs
-    classpath = sourceSets.test.runtimeClasspath
-
-    useJUnitPlatform {
-        includeTags 'integration'
-    }
-}
-```
-
-## JaCoCo Coverage
-
-```groovy
-plugins {
-    id 'jacoco'
-}
-
-jacoco {
-    toolVersion = "0.8.12"
-}
-
-jacocoTestReport {
-    reports {
-        xml.required = true
-        html.required = true
-    }
-}
-
-jacocoTestCoverageVerification {
-    violationRules {
-        rule {
-            limit {
-                minimum = 0.70
-            }
-        }
-    }
-}
-```
-
-## Related Skills
-
-- `spring-boot-4`: Dependencias Spring