oh-my-customcode 0.1.4 → 0.2.1

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

@@ -1,269 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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

@@ -1,337 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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

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

@@ -1,27 +0,0 @@
-# Spring Boot Best Practices Skill
-
-metadata:
-  name: springboot-best-practices
-  category: backend
-  description: Spring Boot patterns for enterprise Java applications
-
-source:
-  type: internal
-  reference:
-    - https://docs.spring.io/spring-boot/docs/current/reference/html/
-    - https://spring.io/guides
-    - https://www.baeldung.com/spring-boot
-
-provides:
-  - Project structure patterns
-  - Dependency injection best practices
-  - REST API design guidelines
-  - Service layer patterns
-  - Data access patterns
-  - Exception handling
-  - Configuration management
-  - Security implementation
-  - Testing strategies
-
-used_by:
-  - springboot-expert

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

@@ -1,25 +0,0 @@
-# Go Best Practices Skill
-
-metadata:
-  name: go-best-practices
-  category: development
-  description: Idiomatic Go patterns from Effective Go
-
-source:
-  type: internal
-  reference: https://go.dev/doc/effective_go
-
-provides:
-  - Go code formatting standards
-  - Naming conventions
-  - Control structure patterns
-  - Function design patterns
-  - Data structure usage
-  - Method receiver guidelines
-  - Interface design
-  - Concurrency patterns
-  - Error handling patterns
-  - Project structure guidelines
-
-used_by:
-  - golang-expert