oh-my-customcode 0.1.0

package/templates/skills/backend/fastapi-best-practices/SKILL.md

@@ -0,0 +1,269 @@
+# FastAPI Best Practices Skill
+
+> **Category**: Backend
+> **Source**: Internal (based on FastAPI docs and community patterns)
+
+## Purpose
+
+Apply FastAPI patterns for building high-performance async APIs.
+
+## Rules
+
+### 1. Project Structure
+
+```yaml
+structure:
+  domain_based: true
+  module_contents:
+    - router.py: API endpoints
+    - schemas.py: Pydantic models
+    - models.py: Database models
+    - service.py: Business logic
+    - dependencies.py: Route validators
+    - constants.py: Module constants
+    - config.py: Module configuration
+    - exceptions.py: Custom exceptions
+    - utils.py: Helper functions
+
+imports:
+  style: explicit
+  example: "from src.auth import constants as auth_constants"
+
+layout: |
+  src/
+  ├── auth/
+  │   ├── router.py
+  │   ├── schemas.py
+  │   ├── models.py
+  │   ├── service.py
+  │   └── dependencies.py
+  ├── users/
+  │   └── ...
+  ├── config.py
+  └── main.py
+```
+
+### 2. Async Patterns
+
+```yaml
+io_intensive:
+  use: "async def"
+  await: "asyncio.sleep(), httpx, asyncpg, etc."
+  example: |
+    async def fetch_data():
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            return response.json()
+
+sync_io:
+  use: "def (regular function)"
+  reason: FastAPI offloads to threadpool automatically
+  example: |
+    def read_file():
+        with open('file.txt') as f:
+            return f.read()
+
+cpu_intensive:
+  avoid: async and threadpool
+  use: separate worker processes
+  example: "Use Celery or multiprocessing"
+
+never:
+  - "time.sleep() in async functions"
+  - "Blocking I/O in async functions"
+```
+
+### 3. Pydantic Models
+
+```yaml
+validation:
+  use_builtin: regex, enums, email, URL validators
+  custom_validators: for complex logic
+
+base_model:
+  create_custom: true
+  purpose: enforce application-wide standards
+  example: |
+    from pydantic import BaseModel
+    from datetime import datetime
+
+    class AppBaseModel(BaseModel):
+        class Config:
+            from_attributes = True
+            json_encoders = {
+                datetime: lambda v: v.isoformat()
+            }
+
+settings:
+  split: across modules
+  avoid: single global configuration
+  example: |
+    # auth/config.py
+    class AuthSettings(BaseSettings):
+        jwt_secret: str
+        jwt_algorithm: str = "HS256"
+
+    # database/config.py
+    class DatabaseSettings(BaseSettings):
+        url: str
+        pool_size: int = 5
+```
+
+### 4. Dependencies
+
+```yaml
+usage:
+  - Dependency injection
+  - Validation against database
+  - Authentication/authorization
+  - Request scoped caching
+
+patterns:
+  chain: avoid code repetition
+  cache: FastAPI caches within request scope
+  decouple: small, reusable functions
+
+example: |
+  async def get_current_user(
+      token: str = Depends(oauth2_scheme),
+      db: Session = Depends(get_db)
+  ) -> User:
+      user = await db.get_user_by_token(token)
+      if not user:
+          raise HTTPException(status_code=401)
+      return user
+
+  async def get_active_user(
+      user: User = Depends(get_current_user)
+  ) -> User:
+      if not user.is_active:
+          raise HTTPException(status_code=403)
+      return user
+```
+
+### 5. Error Handling
+
+```yaml
+custom_exceptions:
+  scope: module-specific
+  purpose: clarity and consistency
+
+pattern: |
+  # auth/exceptions.py
+  class AuthException(Exception):
+      pass
+
+  class InvalidCredentials(AuthException):
+      pass
+
+  class TokenExpired(AuthException):
+      pass
+
+  # auth/router.py
+  @router.post("/login")
+  async def login(credentials: LoginSchema):
+      try:
+          return await auth_service.login(credentials)
+      except InvalidCredentials:
+          raise HTTPException(
+              status_code=401,
+              detail="Invalid credentials"
+          )
+
+exception_handlers: |
+  @app.exception_handler(AuthException)
+  async def auth_exception_handler(request, exc):
+      return JSONResponse(
+          status_code=401,
+          content={"detail": str(exc)}
+      )
+```
+
+### 6. Database
+
+```yaml
+naming:
+  establish: upfront conventions
+  consistency: across all models
+
+migrations:
+  tool: Alembic
+  naming: explicit naming rules
+
+design:
+  approach: SQL-first
+  then: add Pydantic models
+
+patterns: |
+  # Use async database drivers
+  from sqlalchemy.ext.asyncio import AsyncSession
+
+  async def get_user(db: AsyncSession, user_id: int):
+      result = await db.execute(
+          select(User).where(User.id == user_id)
+      )
+      return result.scalar_one_or_none()
+```
+
+### 7. API Design
+
+```yaml
+routing:
+  prefix: meaningful module prefix
+  tags: for documentation grouping
+
+responses:
+  schema: always define response models
+  status_codes: document all possible codes
+
+example: |
+  router = APIRouter(
+      prefix="/users",
+      tags=["users"]
+  )
+
+  @router.get(
+      "/{user_id}",
+      response_model=UserResponse,
+      responses={
+          404: {"model": ErrorResponse}
+      }
+  )
+  async def get_user(user_id: int):
+      ...
+```
+
+### 8. Testing
+
+```yaml
+setup:
+  async_client: from day one
+  structure: mirror module layout
+
+patterns: |
+  import pytest
+  from httpx import AsyncClient
+
+  @pytest.fixture
+  async def client():
+      async with AsyncClient(app=app, base_url="http://test") as ac:
+          yield ac
+
+  @pytest.mark.asyncio
+  async def test_get_user(client):
+      response = await client.get("/users/1")
+      assert response.status_code == 200
+```
+
+## Application
+
+When writing FastAPI code:
+
+1. **Always** use domain-based project structure
+2. **Always** use `async def` for I/O operations
+3. **Prefer** Pydantic for all validation
+4. **Use** dependencies for reusable logic
+5. **Define** module-specific exceptions
+6. **Document** API with response models
+7. **Test** with async client
+8. **Use** Ruff for code quality

package/templates/skills/backend/fastapi-best-practices/index.yaml

@@ -0,0 +1,25 @@
+# FastAPI Best Practices Skill
+
+metadata:
+  name: fastapi-best-practices
+  category: backend
+  description: FastAPI patterns for high-performance async APIs
+
+source:
+  type: internal
+  reference:
+    - https://fastapi.tiangolo.com/
+    - https://github.com/zhanymkanov/fastapi-best-practices
+
+provides:
+  - Project structure patterns
+  - Async/await best practices
+  - Pydantic validation patterns
+  - Dependency injection design
+  - Error handling patterns
+  - Database integration
+  - API design guidelines
+  - Testing patterns
+
+used_by:
+  - fastapi-expert

package/templates/skills/backend/go-backend-best-practices/SKILL.md

@@ -0,0 +1,337 @@
+# Go Backend Best Practices Skill
+
+> **Category**: Backend
+> **Source**: Internal (based on Uber Go Style Guide and Standard Layout)
+
+## Purpose
+
+Apply Go backend patterns for building production-ready services.
+
+## Rules
+
+### 1. Project Structure (Standard Layout)
+
+```yaml
+layout: |
+  project/
+  ├── cmd/
+  │   └── server/
+  │       └── main.go
+  ├── internal/
+  │   ├── handler/
+  │   ├── service/
+  │   ├── repository/
+  │   └── model/
+  ├── pkg/
+  │   └── shared/
+  ├── api/
+  │   └── openapi.yaml
+  ├── configs/
+  ├── scripts/
+  ├── Dockerfile
+  ├── Makefile
+  └── go.mod
+
+directories:
+  cmd: Main applications (one per binary)
+  internal: Private application code
+  pkg: Library code safe for external use
+  api: API definitions (OpenAPI, protobuf)
+  configs: Configuration files
+  scripts: Build and CI scripts
+```
+
+### 2. Error Handling (Uber Style)
+
+```yaml
+principles:
+  - Wrap errors with context using %w
+  - Handle errors once (don't log AND return)
+  - Use sentinel errors for specific conditions
+  - Name error variables with Err prefix
+
+patterns: |
+  // Sentinel errors
+  var (
+      ErrNotFound = errors.New("not found")
+      ErrInvalidInput = errors.New("invalid input")
+  )
+
+  // Wrap with context
+  func getUser(id string) (*User, error) {
+      user, err := db.FindUser(id)
+      if err != nil {
+          return nil, fmt.Errorf("getUser %s: %w", id, err)
+      }
+      return user, nil
+  }
+
+  // Check specific errors
+  if errors.Is(err, ErrNotFound) {
+      return http.StatusNotFound
+  }
+```
+
+### 3. Concurrency (Uber Style)
+
+```yaml
+channels:
+  size: "Use 0 (unbuffered) or 1 only"
+  larger: "Requires careful review"
+
+goroutines:
+  never: fire-and-forget
+  always: wait for completion or manage lifecycle
+
+patterns: |
+  // Wait group for goroutines
+  func process(items []Item) error {
+      var wg sync.WaitGroup
+      errCh := make(chan error, 1)
+
+      for _, item := range items {
+          wg.Add(1)
+          go func(item Item) {
+              defer wg.Done()
+              if err := processItem(item); err != nil {
+                  select {
+                  case errCh <- err:
+                  default:
+                  }
+              }
+          }(item)
+      }
+
+      wg.Wait()
+      close(errCh)
+      return <-errCh
+  }
+
+  // Context for cancellation
+  func longRunningTask(ctx context.Context) error {
+      for {
+          select {
+          case <-ctx.Done():
+              return ctx.Err()
+          default:
+              // do work
+          }
+      }
+  }
+```
+
+### 4. HTTP Server
+
+```yaml
+structure:
+  handler: HTTP layer (request/response)
+  service: Business logic
+  repository: Data access
+
+patterns: |
+  // Handler with dependency injection
+  type UserHandler struct {
+      service UserService
+  }
+
+  func NewUserHandler(s UserService) *UserHandler {
+      return &UserHandler{service: s}
+  }
+
+  func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
+      id := chi.URLParam(r, "id")
+
+      user, err := h.service.GetUser(r.Context(), id)
+      if err != nil {
+          if errors.Is(err, ErrNotFound) {
+              http.Error(w, "user not found", http.StatusNotFound)
+              return
+          }
+          http.Error(w, "internal error", http.StatusInternalServerError)
+          return
+      }
+
+      json.NewEncoder(w).Encode(user)
+  }
+
+  // Router setup
+  func NewRouter(h *UserHandler) *chi.Mux {
+      r := chi.NewRouter()
+      r.Use(middleware.Logger)
+      r.Use(middleware.Recoverer)
+
+      r.Route("/api/v1", func(r chi.Router) {
+          r.Get("/users/{id}", h.GetUser)
+          r.Post("/users", h.CreateUser)
+      })
+
+      return r
+  }
+```
+
+### 5. Dependency Injection
+
+```yaml
+approach: constructor injection
+avoid: global variables
+
+patterns: |
+  // Service with dependencies
+  type UserService struct {
+      repo   UserRepository
+      cache  Cache
+      logger *slog.Logger
+  }
+
+  func NewUserService(
+      repo UserRepository,
+      cache Cache,
+      logger *slog.Logger,
+  ) *UserService {
+      return &UserService{
+          repo:   repo,
+          cache:  cache,
+          logger: logger,
+      }
+  }
+
+  // Wire up in main
+  func main() {
+      logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
+      db := database.New(cfg.DatabaseURL)
+      cache := redis.New(cfg.RedisURL)
+
+      repo := repository.NewUserRepository(db)
+      service := service.NewUserService(repo, cache, logger)
+      handler := handler.NewUserHandler(service)
+
+      router := handler.NewRouter(handler)
+      http.ListenAndServe(":8080", router)
+  }
+```
+
+### 6. Configuration
+
+```yaml
+approach:
+  - Use environment variables
+  - Validate at startup
+  - Group related settings
+
+patterns: |
+  type Config struct {
+      Server   ServerConfig
+      Database DatabaseConfig
+      Redis    RedisConfig
+  }
+
+  type ServerConfig struct {
+      Host         string        `env:"SERVER_HOST" envDefault:"0.0.0.0"`
+      Port         int           `env:"SERVER_PORT" envDefault:"8080"`
+      ReadTimeout  time.Duration `env:"SERVER_READ_TIMEOUT" envDefault:"5s"`
+      WriteTimeout time.Duration `env:"SERVER_WRITE_TIMEOUT" envDefault:"10s"`
+  }
+
+  func LoadConfig() (*Config, error) {
+      var cfg Config
+      if err := env.Parse(&cfg); err != nil {
+          return nil, fmt.Errorf("parse config: %w", err)
+      }
+      return &cfg, nil
+  }
+```
+
+### 7. Testing
+
+```yaml
+patterns:
+  table_driven: for comprehensive coverage
+  interfaces: for mocking
+  parallel: for speed
+
+example: |
+  func TestUserService_GetUser(t *testing.T) {
+      tests := []struct {
+          name    string
+          userID  string
+          mock    func(*MockRepository)
+          want    *User
+          wantErr error
+      }{
+          {
+              name:   "success",
+              userID: "123",
+              mock: func(m *MockRepository) {
+                  m.EXPECT().FindByID("123").Return(&User{ID: "123"}, nil)
+              },
+              want: &User{ID: "123"},
+          },
+          {
+              name:   "not found",
+              userID: "999",
+              mock: func(m *MockRepository) {
+                  m.EXPECT().FindByID("999").Return(nil, ErrNotFound)
+              },
+              wantErr: ErrNotFound,
+          },
+      }
+
+      for _, tt := range tests {
+          t.Run(tt.name, func(t *testing.T) {
+              t.Parallel()
+              ctrl := gomock.NewController(t)
+              repo := NewMockRepository(ctrl)
+              tt.mock(repo)
+
+              svc := NewUserService(repo, nil, slog.Default())
+              got, err := svc.GetUser(context.Background(), tt.userID)
+
+              if !errors.Is(err, tt.wantErr) {
+                  t.Errorf("got error %v, want %v", err, tt.wantErr)
+              }
+              if diff := cmp.Diff(tt.want, got); diff != "" {
+                  t.Errorf("mismatch (-want +got):\n%s", diff)
+              }
+          })
+      }
+  }
+```
+
+### 8. Performance (Uber Style)
+
+```yaml
+guidelines:
+  - Use strconv over fmt for conversions
+  - Pre-allocate slices with known capacity
+  - Avoid repeated string-to-byte conversions
+  - Copy slices/maps at boundaries
+
+patterns: |
+  // Pre-allocate
+  items := make([]Item, 0, len(input))
+
+  // strconv for conversions
+  s := strconv.Itoa(n) // not fmt.Sprintf("%d", n)
+
+  // Copy at boundaries
+  func (s *Store) GetItems() []Item {
+      s.mu.RLock()
+      defer s.mu.RUnlock()
+      items := make([]Item, len(s.items))
+      copy(items, s.items)
+      return items
+  }
+```
+
+## Application
+
+When writing Go backend code:
+
+1. **Always** use standard project layout
+2. **Always** wrap errors with context
+3. **Never** fire-and-forget goroutines
+4. **Use** constructor injection
+5. **Use** table-driven tests
+6. **Handle** errors once
+7. **Copy** data at boundaries
+8. **Validate** config at startup

package/templates/skills/backend/go-backend-best-practices/index.yaml

@@ -0,0 +1,26 @@
+# Go Backend Best Practices Skill
+
+metadata:
+  name: go-backend-best-practices
+  category: backend
+  description: Go backend patterns from Uber style and standard layout
+
+source:
+  type: internal
+  reference:
+    - https://go.dev/doc/effective_go
+    - https://github.com/golang-standards/project-layout
+    - https://github.com/uber-go/guide/blob/master/style.md
+
+provides:
+  - Project structure (standard layout)
+  - Error handling patterns
+  - Concurrency patterns
+  - HTTP server design
+  - Dependency injection
+  - Configuration management
+  - Testing patterns
+  - Performance guidelines
+
+used_by:
+  - go-backend-expert