oh-my-customcode 0.1.3 → 0.2.0

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/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

package/templates/skills/development/kotlin-best-practices/SKILL.md

@@ -1,255 +0,0 @@
-# Kotlin Best Practices Skill
-
-> **Category**: Development
-> **Source**: Internal (based on Kotlin Coding Conventions)
-
-## Purpose
-
-Apply idiomatic Kotlin patterns and best practices from official JetBrains documentation.
-
-## Core Principles
-
-```
-Concise yet readable
-Null safety by design
-Interoperability with Java
-Functional when appropriate
-```
-
-## Rules
-
-### 1. Naming Conventions
-
-```yaml
-packages:
-  style: lowercase, no underscores
-  example: org.example.project
-
-classes_objects:
-  style: UpperCamelCase
-  example: DeclarationProcessor
-
-functions_variables:
-  style: lowerCamelCase
-  example: processDeclarations, declarationCount
-
-constants:
-  style: SCREAMING_SNAKE_CASE
-  example: const val MAX_COUNT = 8
-
-backing_properties:
-  style: underscore prefix
-  example: private val _elementList
-
-acronyms:
-  two_letters: both uppercase (IOStream)
-  three_plus: capitalize first only (XmlFormatter)
-```
-
-### 2. Source File Organization
-
-```yaml
-file_naming:
-  single_class: name after the class (MyClass.kt)
-  multiple_classes: descriptive UpperCamelCase (ProcessDeclarations.kt)
-  platform_specific: add suffix (Platform.jvm.kt)
-
-class_layout:
-  1: Property declarations and initializer blocks
-  2: Secondary constructors
-  3: Method declarations
-  4: Companion object
-
-directory_structure:
-  - Follow package structure with common root omitted
-  - Example: org.example.kotlin.network → network/
-```
-
-### 3. Formatting
-
-```yaml
-indentation:
-  - 4 spaces (no tabs)
-  - Opening brace at end of line
-  - Closing brace on separate line
-
-horizontal_whitespace:
-  around_binary_operators: "a + b"
-  no_around_range: "0..i"
-  no_around_unary: "a++"
-  after_control_keywords: "if (condition)"
-  no_before_parentheses: "method()"
-  never_around_dot: "foo.bar()"
-
-colons:
-  type_supertype: "class Foo : Bar"
-  declaration_type: "val x: Int"
-  always_space_after: true
-
-trailing_commas:
-  recommended: true
-  reason: cleaner diffs, easier reordering
-```
-
-### 4. Functions
-
-```yaml
-expression_bodies:
-  prefer: "fun foo() = 1"
-  over: |
-    fun foo(): Int {
-        return 1
-    }
-
-default_parameters:
-  prefer: "fun foo(a: String = \"a\")"
-  over: overloaded functions
-
-single_line_signatures:
-  if_fits: "fun foo(a: Int): String = ..."
-  otherwise: |
-    fun longMethodName(
-        argument: ArgumentType = defaultValue,
-        argument2: AnotherArgumentType,
-    ): ReturnType { }
-
-unit_return:
-  avoid: "fun foo(): Unit { }"
-  prefer: "fun foo() { }"
-```
-
-### 5. Null Safety
-
-```yaml
-principles:
-  - Prefer non-null types by default
-  - Use ? only when nullability is meaningful
-  - Leverage safe calls (?.) and elvis (?:)
-
-patterns: |
-  // Safe call
-  val length = text?.length
-
-  // Elvis operator
-  val name = user?.name ?: "Anonymous"
-
-  // Let for null checks
-  user?.let {
-      println(it.name)
-  }
-
-  // Not-null assertion (use sparingly)
-  val name = user!!.name
-```
-
-### 6. Idiomatic Patterns
-
-```yaml
-immutability:
-  prefer: "val over var"
-  collections: "listOf() over arrayListOf()"
-
-conditionals:
-  binary: use if
-  multiple: use when
-
-  patterns: |
-    // if expression
-    return if (x) foo() else bar()
-
-    // when expression
-    return when(x) {
-        0 -> "zero"
-        else -> "nonzero"
-    }
-
-functional:
-  prefer: "list.filter { it > 10 }.map { it * 2 }"
-  over: manual loops (except forEach)
-
-ranges:
-  prefer: "for (i in 0..<n)"
-  avoid: "for (i in 0..n - 1)"
-
-type_aliases:
-  use_for: |
-    typealias MouseClickHandler = (Any, MouseEvent) -> Unit
-    typealias PersonIndex = Map<String, Person>
-```
-
-### 7. Lambdas
-
-```yaml
-formatting:
-  - Spaces around curly braces: "list.filter { it > 10 }"
-  - Single lambda outside parentheses
-  - it for single parameter
-
-patterns: |
-  // Outside parentheses
-  list.filter { it > 10 }
-
-  // Multiple parameters
-  list.fold(0) { acc, item -> acc + item }
-
-  // Destructuring
-  map.forEach { (key, value) -> println("$key = $value") }
-```
-
-### 8. Coroutines
-
-```yaml
-principles:
-  - Use suspend functions for async operations
-  - Structured concurrency with scopes
-  - Proper exception handling
-
-patterns: |
-  // Suspend function
-  suspend fun fetchData(): Data {
-      return withContext(Dispatchers.IO) {
-          api.getData()
-      }
-  }
-
-  // Coroutine scope
-  lifecycleScope.launch {
-      val data = fetchData()
-      updateUI(data)
-  }
-
-  // Exception handling
-  try {
-      val result = async { fetchData() }.await()
-  } catch (e: Exception) {
-      handleError(e)
-  }
-```
-
-### 9. Documentation
-
-```yaml
-format: |
-  /**
-   * Returns the absolute value of the given [number].
-   */
-  fun abs(number: Int): Int { ... }
-
-best_practices:
-  - Incorporate parameters into description
-  - Use brackets for parameter references
-  - Use @param/@return only for lengthy descriptions
-```
-
-## Application
-
-When writing or reviewing Kotlin code:
-
-1. **Always** prefer val over var
-2. **Always** use null-safe types appropriately
-3. **Prefer** expression bodies for simple functions
-4. **Prefer** functional operations over loops
-5. **Use** default parameters over overloads
-6. **Use** when for multiple conditions
-7. **Leverage** extension functions
-8. **Document** public APIs

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

@@ -1,27 +0,0 @@
-# Kotlin Best Practices Skill
-
-metadata:
-  name: kotlin-best-practices
-  category: development
-  description: Idiomatic Kotlin patterns from JetBrains conventions
-
-source:
-  type: internal
-  reference:
-    - https://kotlinlang.org/docs/coding-conventions.html
-    - https://kotlinlang.org/docs/idioms.html
-    - https://developer.android.com/kotlin/style-guide
-
-provides:
-  - Kotlin naming conventions
-  - Source file organization
-  - Formatting standards
-  - Function design patterns
-  - Null safety patterns
-  - Idiomatic expressions
-  - Lambda best practices
-  - Coroutine patterns
-  - Documentation guidelines
-
-used_by:
-  - kotlin-expert