@dewtech/dare-cli 3.0.0 → 3.2.0

package/templates/stacks/go-gin/internal/repository/users_repository.go.tpl

@@ -0,0 +1,79 @@
+// Package repository — pgx-backed DB queries for the User aggregate.
+//
+// Production setups can replace these queries with sqlc-generated code from
+// db/queries/users.sql by running `sqlc generate` (output goes to
+// internal/repository/sqlcgen/). The hand-written queries below are kept as
+// a fallback so the project compiles before sqlc has been run.
+package repository
+
+import (
+	"context"
+	"errors"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"{{moduleName}}/internal/model"
+)
+
+type UsersRepository struct {
+	pool *pgxpool.Pool
+}
+
+func NewUsersRepository(pool *pgxpool.Pool) *UsersRepository {
+	return &UsersRepository{pool: pool}
+}
+
+func (r *UsersRepository) FindByEmail(ctx context.Context, email string) (*model.User, error) {
+	row := r.pool.QueryRow(ctx,
+		`SELECT id, email, password, role, created_at, updated_at FROM users WHERE email = $1`, email)
+	u := &model.User{}
+	if err := row.Scan(&u.ID, &u.Email, &u.Password, &u.Role, &u.CreatedAt, &u.UpdatedAt); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return u, nil
+}
+
+func (r *UsersRepository) Page(ctx context.Context, offset, limit int64) ([]*model.User, error) {
+	rows, err := r.pool.Query(ctx,
+		`SELECT id, email, password, role, created_at, updated_at
+		 FROM users ORDER BY created_at DESC LIMIT $1 OFFSET $2`, limit, offset)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []*model.User
+	for rows.Next() {
+		u := &model.User{}
+		if err := rows.Scan(&u.ID, &u.Email, &u.Password, &u.Role, &u.CreatedAt, &u.UpdatedAt); err != nil {
+			return nil, err
+		}
+		out = append(out, u)
+	}
+	return out, rows.Err()
+}
+
+func (r *UsersRepository) Count(ctx context.Context) (int64, error) {
+	var total int64
+	err := r.pool.QueryRow(ctx, `SELECT COUNT(*) FROM users`).Scan(&total)
+	return total, err
+}
+
+func (r *UsersRepository) Create(ctx context.Context, email, passwordHash, role string) (*model.User, error) {
+	u := &model.User{}
+	err := r.pool.QueryRow(ctx,
+		`INSERT INTO users (id, email, password, role)
+		 VALUES ($1, $2, $3, $4)
+		 RETURNING id, email, password, role, created_at, updated_at`,
+		uuid.New(), email, passwordHash, role,
+	).Scan(&u.ID, &u.Email, &u.Password, &u.Role, &u.CreatedAt, &u.UpdatedAt)
+	if err != nil {
+		return nil, err
+	}
+	return u, nil
+}

package/templates/stacks/go-gin/internal/service/auth_service.go.tpl

@@ -0,0 +1,55 @@
+// Package service — business logic. Calls repositories, never DB drivers.
+package service
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"golang.org/x/crypto/bcrypt"
+
+	"{{moduleName}}/internal/config"
+	"{{moduleName}}/internal/repository"
+)
+
+var ErrInvalidCredentials = errors.New("invalid credentials")
+
+type AuthService struct {
+	repo *repository.UsersRepository
+	cfg  *config.Config
+}
+
+func NewAuthService(r *repository.UsersRepository, cfg *config.Config) *AuthService {
+	return &AuthService{repo: r, cfg: cfg}
+}
+
+func (s *AuthService) Login(ctx context.Context, email, password string) (string, int64, error) {
+	email = strings.TrimSpace(strings.ToLower(email))
+	user, err := s.repo.FindByEmail(ctx, email)
+	if err != nil {
+		return "", 0, err
+	}
+	if user == nil {
+		return "", 0, ErrInvalidCredentials
+	}
+	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)); err != nil {
+		return "", 0, ErrInvalidCredentials
+	}
+
+	expHours := s.cfg.JWTExpHours
+	expiresAt := time.Now().Add(time.Duration(expHours) * time.Hour)
+	claims := jwt.MapClaims{
+		"sub":   user.ID.String(),
+		"email": user.Email,
+		"role":  user.Role,
+		"exp":   expiresAt.Unix(),
+	}
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	signed, err := token.SignedString([]byte(s.cfg.JWTSecret))
+	if err != nil {
+		return "", 0, err
+	}
+	return signed, int64(expHours) * 3600, nil
+}

package/templates/stacks/go-gin/internal/service/users_service.go.tpl

@@ -0,0 +1,53 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	"golang.org/x/crypto/bcrypt"
+
+	"{{moduleName}}/internal/config"
+	"{{moduleName}}/internal/model"
+	"{{moduleName}}/internal/repository"
+)
+
+var ErrEmailExists = errors.New("email already in use")
+
+type UsersService struct {
+	repo *repository.UsersRepository
+	cfg  *config.Config
+}
+
+func NewUsersService(r *repository.UsersRepository, cfg *config.Config) *UsersService {
+	return &UsersService{repo: r, cfg: cfg}
+}
+
+func (s *UsersService) Page(ctx context.Context, page, limit int) ([]*model.User, int64, error) {
+	offset := int64((page - 1) * limit)
+	items, err := s.repo.Page(ctx, offset, int64(limit))
+	if err != nil {
+		return nil, 0, err
+	}
+	total, err := s.repo.Count(ctx)
+	if err != nil {
+		return nil, 0, err
+	}
+	return items, total, nil
+}
+
+func (s *UsersService) Create(ctx context.Context, email, password, role string) (*model.User, error) {
+	email = strings.TrimSpace(strings.ToLower(email))
+	existing, err := s.repo.FindByEmail(ctx, email)
+	if err != nil {
+		return nil, err
+	}
+	if existing != nil {
+		return nil, ErrEmailExists
+	}
+	hash, err := bcrypt.GenerateFromPassword([]byte(password), s.cfg.BcryptCost)
+	if err != nil {
+		return nil, err
+	}
+	return s.repo.Create(ctx, email, string(hash), role)
+}

package/templates/stacks/go-gin/llms.txt.tpl

@@ -0,0 +1,54 @@
+# {{projectName}}
+
+DARE-shaped Go API on Gin 1.10+. Layered Design: Handler → Service → Repository → Model.
+
+## Setup
+
+```bash
+cp .env.example .env
+docker compose up -d postgres
+go mod tidy
+sqlc generate          # type-safe DB code from db/queries/*.sql
+swag init -g cmd/server/main.go -o docs   # OpenAPI from annotations
+go run ./cmd/server
+```
+
+## Commands
+
+- `go run ./cmd/server` — dev server (port 8000)
+- `go test ./...` — full test suite
+- `golangci-lint run` — lint
+- `govulncheck ./...` — vuln scan
+- `sqlc generate` — regenerate repos from SQL
+- `swag init -g cmd/server/main.go -o docs` — refresh OpenAPI
+
+## Endpoints
+
+| Method | Path | Auth | Description |
+|---|---|---|---|
+| POST | `/auth/login` | none | Exchange email+password for JWT |
+| GET | `/auth/me` | Bearer | Current user |
+| GET | `/users` | Bearer | List (query: page, limit) |
+| POST | `/users` | Bearer (admin) | Create user |
+| GET | `/ws` | upgrade | WebSocket echo |
+| GET | `/openapi.json` | none | OpenAPI document |
+| GET | `/swagger/index.html` | none | Swagger UI |
+
+## Layered Design
+
+- `internal/handler/` — Gin handlers (HTTP)
+- `internal/service/` — business logic
+- `internal/repository/` — sqlx/pgx queries via sqlc-generated code
+- `internal/model/` — domain structs
+- `internal/middleware/` — JWT + rate limit
+- `internal/llm/` — provider abstraction
+
+Handlers never call pgx directly.
+
+## Env vars
+
+See `.env.example`. Required: `DATABASE_URL`, `JWT_SECRET`.
+
+## DARE skills
+
+See `.dare/skills.yml`.

package/templates/stacks/go-gin/openapi.json.tpl

@@ -0,0 +1,46 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "{{projectName}}",
+    "version": "0.1.0",
+    "description": "DARE-shaped Gin API. Regenerate from annotations: swag init -g cmd/server/main.go -o docs"
+  },
+  "paths": {
+    "/auth/login": {
+      "post": {
+        "summary": "Exchange email+password for JWT",
+        "responses": { "200": { "description": "JWT issued" }, "401": { "description": "Invalid credentials" } }
+      }
+    },
+    "/auth/me": {
+      "get": {
+        "summary": "Current user",
+        "security": [{ "bearer": [] }],
+        "responses": { "200": { "description": "User" }, "401": { "description": "Unauthorized" } }
+      }
+    },
+    "/users": {
+      "get": {
+        "summary": "List users",
+        "security": [{ "bearer": [] }],
+        "responses": { "200": { "description": "Page of users" } }
+      },
+      "post": {
+        "summary": "Create user (admin)",
+        "security": [{ "bearer": [] }],
+        "responses": { "201": { "description": "Created" }, "403": { "description": "Forbidden" } }
+      }
+    },
+    "/ws": {
+      "get": {
+        "summary": "WebSocket echo",
+        "responses": { "101": { "description": "Switching Protocols" } }
+      }
+    }
+  },
+  "components": {
+    "securitySchemes": {
+      "bearer": { "type": "http", "scheme": "bearer", "bearerFormat": "JWT" }
+    }
+  }
+}

package/templates/stacks/go-gin/sqlc.yaml

@@ -0,0 +1,14 @@
+version: "2"
+sql:
+  - engine: "postgresql"
+    queries: "db/queries"
+    schema: "db/migrations"
+    gen:
+      go:
+        package: "sqlcgen"
+        out: "internal/repository/sqlcgen"
+        sql_package: "pgx/v5"
+        emit_json_tags: true
+        emit_prepared_queries: false
+        emit_interface: false
+        emit_exact_table_names: false

package/templates/stacks/go-gin/tests/smoke_test.go.tpl

@@ -0,0 +1,22 @@
+// Smoke tests — exercise pure helpers without a DB.
+package tests
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"{{moduleName}}/internal/config"
+)
+
+func TestConfigFromEnvDefaultsAreSane(t *testing.T) {
+	t.Setenv("DATABASE_URL", "postgres://u:p@localhost:5432/x?sslmode=disable")
+	t.Setenv("APP_PORT", "")
+	os.Unsetenv("APP_PORT")
+	cfg, err := config.FromEnv()
+	require.NoError(t, err)
+	require.Equal(t, 8000, cfg.AppPort)
+	require.GreaterOrEqual(t, cfg.RateLimitBurst, cfg.RateLimitPerSec)
+	require.NotEmpty(t, cfg.CORSOrigins)
+}

package/templates/stacks/go-stdlib/.dare/skills.yml

@@ -0,0 +1,11 @@
+version: 1
+skills:
+  - id: skill-go-stdlib-api
+    source: skill-go-stdlib-api
+    description: net/http stdlib + sqlc + pgx Layered Design (no framework)
+  - id: dare-ax
+    source: dare-ax
+    description: Agent eXperience invariants (llms.txt, OpenAPI, --json, rate limit)
+  - id: dare-layered-design
+    source: dare-layered-design
+    description: Handler → Service → Repository → Model 4-layer architecture

package/templates/stacks/go-stdlib/.env.example

@@ -0,0 +1,24 @@
+# Application
+APP_PORT=8000
+LOG_LEVEL=info
+
+# Database
+DATABASE_URL=postgres://user:pass@localhost:5432/myapi?sslmode=disable
+
+# JWT auth
+JWT_SECRET=replace-me-in-prod
+JWT_EXP_HOURS=1
+
+# Password hashing
+BCRYPT_COST=12
+
+# Rate limit (token bucket per IP)
+RATE_LIMIT_PER_SEC=10
+RATE_LIMIT_BURST=20
+
+# CORS
+CORS_ORIGINS=http://localhost:3000
+
+# LLM
+LLM_PROVIDER=dummy
+# OPENAI_API_KEY=

package/templates/stacks/go-stdlib/.github/workflows/dare-ci.yml

@@ -0,0 +1,42 @@
+name: DARE CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  audit:
+    name: govulncheck
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22"
+      - run: go install golang.org/x/vuln/cmd/govulncheck@latest
+      - run: govulncheck ./...
+
+  lint:
+    name: golangci-lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22"
+      - uses: golangci/golangci-lint-action@v6
+        with:
+          version: v1.61
+
+  test:
+    name: go test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22"
+      - run: go mod download
+      - run: go test ./...

package/templates/stacks/go-stdlib/README.md.tpl

@@ -0,0 +1,41 @@
+# {{projectName}}
+
+DARE-shaped Go API on **net/http** (no framework). Layered Design (Handler → Service → Repository → Model).
+
+## Setup
+
+```bash
+cp .env.example .env
+docker compose up -d postgres
+go mod tidy
+go install github.com/sqlc-dev/sqlc/cmd/sqlc@latest
+sqlc generate
+go run ./cmd/server
+```
+
+## Endpoints
+
+- `POST /auth/login` — exchange email/password for JWT
+- `GET /auth/me` — current user (Bearer JWT)
+- `GET /users` — list users (paginated)
+- `POST /users` — create user (admin only)
+- `GET /ws` — WebSocket echo
+- `GET /openapi.json` — OpenAPI surface (static)
+
+## Commands
+
+- `go run ./cmd/server` — dev server (port 8000)
+- `go test ./...` — tests
+- `golangci-lint run` — lint
+- `govulncheck ./...` — vuln scan
+- `sqlc generate` — regenerate type-safe DB code
+
+## Why no framework?
+
+Go 1.22's `http.ServeMux` supports method + path patterns (e.g. `POST /auth/login`),
+which removes the historical reason for using Gin / Echo / Chi. This template uses
+stdlib for routing, middleware chaining, and JSON serialization.
+
+## DARE Method
+
+See `.dare/skills.yml`.

package/templates/stacks/go-stdlib/cmd/server/main.go.tpl

@@ -0,0 +1,82 @@
+// {{projectName}} — net/http stdlib API entrypoint.
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+
+	"github.com/joho/godotenv"
+
+	"{{moduleName}}/internal/config"
+	"{{moduleName}}/internal/db"
+	"{{moduleName}}/internal/handler"
+	"{{moduleName}}/internal/middleware"
+	"{{moduleName}}/internal/repository"
+	"{{moduleName}}/internal/service"
+)
+
+func main() {
+	_ = godotenv.Load()
+
+	cfg, err := config.FromEnv()
+	if err != nil {
+		log.Fatalf("config: %v", err)
+	}
+
+	pool, err := db.Connect(context.Background(), cfg.DatabaseURL)
+	if err != nil {
+		log.Fatalf("db: %v", err)
+	}
+	defer pool.Close()
+
+	repo := repository.NewUsersRepository(pool)
+	svcAuth := service.NewAuthService(repo, cfg)
+	svcUsers := service.NewUsersService(repo, cfg)
+
+	authH := handler.NewAuthHandler(svcAuth, svcUsers, cfg)
+	usersH := handler.NewUsersHandler(svcUsers)
+	wsH := handler.NewWSHandler()
+
+	mux := http.NewServeMux()
+
+	// Public routes
+	mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, _ *http.Request) {
+		_ = json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+	})
+	mux.HandleFunc("GET /openapi.json", func(w http.ResponseWriter, _ *http.Request) {
+		b, _ := os.ReadFile("openapi.json")
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write(b)
+	})
+	mux.HandleFunc("POST /auth/login", authH.Login)
+
+	// Bearer-protected routes
+	jwtMW := middleware.JWT(cfg)
+	mux.Handle("GET /auth/me", jwtMW(http.HandlerFunc(authH.Me)))
+	mux.Handle("GET /users", jwtMW(http.HandlerFunc(usersH.List)))
+	mux.Handle("POST /users", jwtMW(http.HandlerFunc(usersH.Create)))
+
+	// WebSocket — upgrade endpoint
+	mux.HandleFunc("GET /ws", wsH.Handle)
+
+	// Global middleware chain
+	handler := middleware.Chain(
+		mux,
+		middleware.CORS(cfg.CORSOrigins),
+		middleware.RateLimit(cfg.RateLimitPerSec, cfg.RateLimitBurst),
+	)
+
+	addr := ":" + strconv.Itoa(cfg.AppPort)
+	log.Printf("listening on %s", addr)
+	srv := &http.Server{
+		Addr:    addr,
+		Handler: handler,
+	}
+	if err := srv.ListenAndServe(); err != nil {
+		log.Fatal(err)
+	}
+}

package/templates/stacks/go-stdlib/db/migrations/0001_create_users.down.sql

@@ -0,0 +1,2 @@
+DROP INDEX IF EXISTS ix_users_email;
+DROP TABLE IF EXISTS users;

package/templates/stacks/go-stdlib/db/migrations/0001_create_users.up.sql

@@ -0,0 +1,12 @@
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+CREATE TABLE IF NOT EXISTS users (
+    id          UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    email       VARCHAR(254) NOT NULL UNIQUE,
+    password    VARCHAR(255) NOT NULL,
+    role        VARCHAR(16) NOT NULL DEFAULT 'USER',
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS ix_users_email ON users (email);

package/templates/stacks/go-stdlib/db/queries/users.sql

@@ -0,0 +1,23 @@
+-- name: FindUserByEmail :one
+SELECT id, email, password, role, created_at, updated_at
+FROM users
+WHERE email = $1;
+
+-- name: GetUserByID :one
+SELECT id, email, password, role, created_at, updated_at
+FROM users
+WHERE id = $1;
+
+-- name: ListUsers :many
+SELECT id, email, password, role, created_at, updated_at
+FROM users
+ORDER BY created_at DESC
+LIMIT $1 OFFSET $2;
+
+-- name: CountUsers :one
+SELECT COUNT(*) FROM users;
+
+-- name: CreateUser :one
+INSERT INTO users (id, email, password, role)
+VALUES ($1, $2, $3, $4)
+RETURNING id, email, password, role, created_at, updated_at;

package/templates/stacks/go-stdlib/gitignore

@@ -0,0 +1,6 @@
+/bin/
+/vendor/
+.env
+.env.local
+*.log
+.DS_Store

package/templates/stacks/go-stdlib/go.mod.tpl

@@ -0,0 +1,15 @@
+module {{moduleName}}
+
+go 1.22
+
+require (
+	github.com/caarlos0/env/v11 v11.2.2
+	github.com/coder/websocket v1.8.12
+	github.com/golang-jwt/jwt/v5 v5.2.1
+	github.com/google/uuid v1.6.0
+	github.com/jackc/pgx/v5 v5.7.1
+	github.com/joho/godotenv v1.5.1
+	github.com/stretchr/testify v1.9.0
+	golang.org/x/crypto v0.28.0
+	golang.org/x/time v0.7.0
+)

package/templates/stacks/go-stdlib/internal/config/config.go

@@ -0,0 +1,41 @@
+// Package config — runtime configuration from environment via caarlos0/env.
+package config
+
+import (
+	"strings"
+
+	"github.com/caarlos0/env/v11"
+)
+
+type Config struct {
+	AppPort         int      `env:"APP_PORT" envDefault:"8000"`
+	DatabaseURL     string   `env:"DATABASE_URL,required"`
+	JWTSecret       string   `env:"JWT_SECRET" envDefault:"replace-me-in-prod"`
+	JWTExpHours     int      `env:"JWT_EXP_HOURS" envDefault:"1"`
+	BcryptCost      int      `env:"BCRYPT_COST" envDefault:"12"`
+	RateLimitPerSec int      `env:"RATE_LIMIT_PER_SEC" envDefault:"10"`
+	RateLimitBurst  int      `env:"RATE_LIMIT_BURST" envDefault:"20"`
+	CORSOriginsRaw  string   `env:"CORS_ORIGINS" envDefault:"http://localhost:3000"`
+	LLMProvider     string   `env:"LLM_PROVIDER" envDefault:"dummy"`
+	CORSOrigins     []string `env:"-"`
+}
+
+func FromEnv() (*Config, error) {
+	cfg := &Config{}
+	if err := env.Parse(cfg); err != nil {
+		return nil, err
+	}
+	cfg.CORSOrigins = splitAndTrim(cfg.CORSOriginsRaw)
+	return cfg, nil
+}
+
+func splitAndTrim(s string) []string {
+	parts := strings.Split(s, ",")
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if t := strings.TrimSpace(p); t != "" {
+			out = append(out, t)
+		}
+	}
+	return out
+}

package/templates/stacks/go-stdlib/internal/db/postgres.go.tpl

@@ -0,0 +1,24 @@
+// Package db — pgx connection pool.
+package db
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func Connect(ctx context.Context, url string) (*pgxpool.Pool, error) {
+	cfg, err := pgxpool.ParseConfig(url)
+	if err != nil {
+		return nil, err
+	}
+	pool, err := pgxpool.NewWithConfig(ctx, cfg)
+	if err != nil {
+		return nil, err
+	}
+	if err := pool.Ping(ctx); err != nil {
+		pool.Close()
+		return nil, err
+	}
+	return pool, nil
+}