oh-my-customcode 0.1.0

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

@@ -0,0 +1,356 @@
+# Spring Boot Best Practices Skill
+
+> **Category**: Backend
+> **Source**: Internal (based on Spring documentation and Baeldung)
+
+## Purpose
+
+Apply Spring Boot patterns for building enterprise-grade applications.
+
+## Rules
+
+### 1. Project Structure
+
+```yaml
+structure:
+  layout: layered architecture
+  packages:
+    - controller: REST endpoints
+    - service: Business logic
+    - repository: Data access
+    - model/entity: Domain objects
+    - dto: Data transfer objects
+    - config: Configuration classes
+    - exception: Custom exceptions
+
+example: |
+  com.example.app/
+  ├── controller/
+  │   └── UserController.java
+  ├── service/
+  │   ├── UserService.java
+  │   └── impl/UserServiceImpl.java
+  ├── repository/
+  │   └── UserRepository.java
+  ├── model/
+  │   └── User.java
+  ├── dto/
+  │   ├── UserRequest.java
+  │   └── UserResponse.java
+  ├── config/
+  │   └── SecurityConfig.java
+  └── exception/
+      └── UserNotFoundException.java
+```
+
+### 2. Dependency Injection
+
+```yaml
+prefer:
+  - Constructor injection over field injection
+  - Interface-based dependencies
+  - @RequiredArgsConstructor with final fields
+
+patterns: |
+  // GOOD: Constructor injection
+  @Service
+  @RequiredArgsConstructor
+  public class UserService {
+      private final UserRepository userRepository;
+      private final EmailService emailService;
+  }
+
+  // AVOID: Field injection
+  @Service
+  public class UserService {
+      @Autowired
+      private UserRepository userRepository; // Not recommended
+  }
+```
+
+### 3. REST API Design
+
+```yaml
+controller:
+  annotations:
+    - "@RestController"
+    - "@RequestMapping with base path"
+    - "@Validated for input validation"
+
+patterns: |
+  @RestController
+  @RequestMapping("/api/v1/users")
+  @RequiredArgsConstructor
+  public class UserController {
+
+      private final UserService userService;
+
+      @GetMapping("/{id}")
+      public ResponseEntity<UserResponse> getUser(@PathVariable Long id) {
+          return ResponseEntity.ok(userService.findById(id));
+      }
+
+      @PostMapping
+      @ResponseStatus(HttpStatus.CREATED)
+      public UserResponse createUser(@Valid @RequestBody UserRequest request) {
+          return userService.create(request);
+      }
+
+      @PutMapping("/{id}")
+      public UserResponse updateUser(
+          @PathVariable Long id,
+          @Valid @RequestBody UserRequest request
+      ) {
+          return userService.update(id, request);
+      }
+
+      @DeleteMapping("/{id}")
+      @ResponseStatus(HttpStatus.NO_CONTENT)
+      public void deleteUser(@PathVariable Long id) {
+          userService.delete(id);
+      }
+  }
+```
+
+### 4. Service Layer
+
+```yaml
+principles:
+  - Business logic in service layer
+  - Transaction boundaries at service level
+  - Interface + implementation pattern
+
+patterns: |
+  public interface UserService {
+      UserResponse findById(Long id);
+      UserResponse create(UserRequest request);
+  }
+
+  @Service
+  @Transactional(readOnly = true)
+  @RequiredArgsConstructor
+  public class UserServiceImpl implements UserService {
+
+      private final UserRepository userRepository;
+      private final UserMapper userMapper;
+
+      @Override
+      public UserResponse findById(Long id) {
+          User user = userRepository.findById(id)
+              .orElseThrow(() -> new UserNotFoundException(id));
+          return userMapper.toResponse(user);
+      }
+
+      @Override
+      @Transactional
+      public UserResponse create(UserRequest request) {
+          User user = userMapper.toEntity(request);
+          return userMapper.toResponse(userRepository.save(user));
+      }
+  }
+```
+
+### 5. Data Access
+
+```yaml
+repository:
+  use: Spring Data JPA
+  custom_queries: "@Query annotation or method naming"
+
+patterns: |
+  public interface UserRepository extends JpaRepository<User, Long> {
+
+      Optional<User> findByEmail(String email);
+
+      @Query("SELECT u FROM User u WHERE u.status = :status")
+      List<User> findByStatus(@Param("status") UserStatus status);
+
+      @Query(value = "SELECT * FROM users WHERE created_at > :date",
+             nativeQuery = true)
+      List<User> findRecentUsers(@Param("date") LocalDateTime date);
+  }
+
+entity: |
+  @Entity
+  @Table(name = "users")
+  @Getter
+  @NoArgsConstructor(access = AccessLevel.PROTECTED)
+  public class User {
+
+      @Id
+      @GeneratedValue(strategy = GenerationType.IDENTITY)
+      private Long id;
+
+      @Column(nullable = false, unique = true)
+      private String email;
+
+      @Enumerated(EnumType.STRING)
+      private UserStatus status;
+
+      @CreatedDate
+      private LocalDateTime createdAt;
+  }
+```
+
+### 6. Exception Handling
+
+```yaml
+global_handler:
+  use: "@ControllerAdvice"
+  custom_exceptions: domain-specific
+
+patterns: |
+  @RestControllerAdvice
+  public class GlobalExceptionHandler {
+
+      @ExceptionHandler(UserNotFoundException.class)
+      @ResponseStatus(HttpStatus.NOT_FOUND)
+      public ErrorResponse handleUserNotFound(UserNotFoundException ex) {
+          return new ErrorResponse("USER_NOT_FOUND", ex.getMessage());
+      }
+
+      @ExceptionHandler(MethodArgumentNotValidException.class)
+      @ResponseStatus(HttpStatus.BAD_REQUEST)
+      public ErrorResponse handleValidation(MethodArgumentNotValidException ex) {
+          List<String> errors = ex.getBindingResult()
+              .getFieldErrors()
+              .stream()
+              .map(e -> e.getField() + ": " + e.getDefaultMessage())
+              .toList();
+          return new ErrorResponse("VALIDATION_ERROR", errors);
+      }
+  }
+```
+
+### 7. Configuration
+
+```yaml
+profiles:
+  use: application-{profile}.yml
+  externalize: sensitive values
+
+patterns: |
+  # application.yml
+  spring:
+    profiles:
+      active: ${SPRING_PROFILES_ACTIVE:local}
+    datasource:
+      url: ${DATABASE_URL}
+      username: ${DATABASE_USERNAME}
+      password: ${DATABASE_PASSWORD}
+
+  # application-local.yml
+  spring:
+    datasource:
+      url: jdbc:h2:mem:testdb
+      driver-class-name: org.h2.Driver
+
+configuration_class: |
+  @Configuration
+  @ConfigurationProperties(prefix = "app")
+  @Validated
+  public class AppProperties {
+
+      @NotBlank
+      private String name;
+
+      @Min(1)
+      private int maxConnections;
+
+      // getters, setters
+  }
+```
+
+### 8. Security
+
+```yaml
+principles:
+  - Use Spring Security
+  - Externalize secrets
+  - Implement proper authentication
+
+patterns: |
+  @Configuration
+  @EnableWebSecurity
+  @RequiredArgsConstructor
+  public class SecurityConfig {
+
+      private final JwtTokenProvider tokenProvider;
+
+      @Bean
+      public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+          return http
+              .csrf(csrf -> csrf.disable())
+              .sessionManagement(session ->
+                  session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+              .authorizeHttpRequests(auth -> auth
+                  .requestMatchers("/api/v1/auth/**").permitAll()
+                  .requestMatchers("/api/v1/admin/**").hasRole("ADMIN")
+                  .anyRequest().authenticated())
+              .addFilterBefore(jwtFilter(), UsernamePasswordAuthenticationFilter.class)
+              .build();
+      }
+  }
+```
+
+### 9. Testing
+
+```yaml
+layers:
+  unit: "@MockBean, Mockito"
+  integration: "@SpringBootTest"
+  slice: "@WebMvcTest, @DataJpaTest"
+
+patterns: |
+  // Controller test
+  @WebMvcTest(UserController.class)
+  class UserControllerTest {
+
+      @Autowired
+      private MockMvc mockMvc;
+
+      @MockBean
+      private UserService userService;
+
+      @Test
+      void getUser_shouldReturnUser() throws Exception {
+          given(userService.findById(1L))
+              .willReturn(new UserResponse(1L, "test@example.com"));
+
+          mockMvc.perform(get("/api/v1/users/1"))
+              .andExpect(status().isOk())
+              .andExpect(jsonPath("$.email").value("test@example.com"));
+      }
+  }
+
+  // Repository test
+  @DataJpaTest
+  class UserRepositoryTest {
+
+      @Autowired
+      private UserRepository userRepository;
+
+      @Test
+      void findByEmail_shouldReturnUser() {
+          User user = userRepository.save(new User("test@example.com"));
+
+          Optional<User> found = userRepository.findByEmail("test@example.com");
+
+          assertThat(found).isPresent();
+          assertThat(found.get().getEmail()).isEqualTo("test@example.com");
+      }
+  }
+```
+
+## Application
+
+When writing Spring Boot code:
+
+1. **Always** use constructor injection
+2. **Always** use layered architecture
+3. **Prefer** interface-based services
+4. **Use** DTOs for API contracts
+5. **Handle** exceptions globally
+6. **Externalize** configuration
+7. **Secure** endpoints properly
+8. **Test** each layer appropriately

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

@@ -0,0 +1,27 @@
+# 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/SKILL.md

@@ -0,0 +1,202 @@
+# Go Best Practices Skill
+
+> **Category**: Development
+> **Source**: Internal (based on Effective Go)
+
+## Purpose
+
+Apply idiomatic Go patterns and best practices from official Go documentation.
+
+## Rules
+
+### 1. Formatting
+
+```yaml
+rules:
+  - Use gofmt for all code formatting
+  - Indentation uses tabs, not spaces
+  - No line length limit, but break long lines sensibly
+  - Let gofmt handle alignment
+```
+
+### 2. Naming Conventions
+
+```yaml
+package_names:
+  - Short, concise, lowercase, single-word
+  - No underscores or mixedCaps
+  - Name is basename of source directory
+  - Example: bufio, not bufIO or buf_io
+
+getters:
+  - No "Get" prefix for getters
+  - obj.Owner() not obj.GetOwner()
+  - Setter can use "Set": obj.SetOwner(user)
+
+interface_names:
+  - One-method interfaces: method name + "er"
+  - Reader, Writer, Formatter, CloseNotifier
+  - Avoid stealing standard names unless same signature
+
+mixedCaps:
+  - Use MixedCaps or mixedCaps, never underscores
+  - Exported: MixedCaps (uppercase first)
+  - Unexported: mixedCaps (lowercase first)
+```
+
+### 3. Control Structures
+
+```yaml
+if_statements:
+  - Accept initialization statement
+  - Prefer: if err := file.Chmod(0664); err != nil
+  - Omit else when if ends with break/continue/return
+  - Avoid unnecessary else
+
+for_loops:
+  - Go's only loop construct
+  - for init; condition; post { } - like C for
+  - for condition { } - like C while
+  - for { } - infinite loop
+  - Use range for strings, slices, arrays, maps, channels
+
+switch:
+  - Cases don't fall through by default
+  - Use fallthrough keyword if needed
+  - Multiple cases: case '0', '1', '2'
+  - Type switch: switch v := x.(type)
+```
+
+### 4. Functions
+
+```yaml
+multiple_returns:
+  - Return multiple values for result + error
+  - func (file *File) Write(b []byte) (n int, err error)
+
+named_results:
+  - Document return values with names
+  - Can simplify code but use judiciously
+  - Unnamed returns OK for short functions
+
+defer:
+  - Executes when function returns
+  - LIFO order for multiple defers
+  - Use for cleanup: unlock mutexes, close files
+  - Arguments evaluated when defer executes, not when called
+```
+
+### 5. Data
+
+```yaml
+new_vs_make:
+  - new(T): allocates zeroed storage, returns *T
+  - make(T, args): creates slices, maps, channels only
+  - make returns initialized (not zeroed) value of type T
+
+slices:
+  - Backed by arrays, can grow
+  - append() to add elements
+  - copy() for safe duplication
+  - Slice of slice shares underlying array
+
+maps:
+  - Reference type, nil until initialized
+  - make(map[KeyType]ValueType)
+  - Comma ok idiom: val, ok := map[key]
+  - delete(map, key) to remove
+```
+
+### 6. Methods
+
+```yaml
+pointer_vs_value_receivers:
+  - Pointer receiver: can modify, no copy overhead
+  - Value receiver: safe from modification
+  - If any method needs pointer, all should use pointer
+  - Rule: values immutable, pointers mutable
+```
+
+### 7. Interfaces
+
+```yaml
+design:
+  - Interfaces define behavior, not data
+  - Small interfaces (1-3 methods) preferred
+  - Accept interfaces, return structs
+  - If type implements interface, it satisfies implicitly
+
+common_interfaces:
+  - io.Reader: Read(p []byte) (n int, err error)
+  - io.Writer: Write(p []byte) (n int, err error)
+  - fmt.Stringer: String() string
+  - error: Error() string
+```
+
+### 8. Concurrency
+
+```yaml
+goroutines:
+  - Lightweight, multiplexed onto OS threads
+  - go function() to start
+  - Don't communicate by sharing memory
+  - Share memory by communicating
+
+channels:
+  - Primary synchronization mechanism
+  - ch := make(chan int) - unbuffered
+  - ch := make(chan int, 100) - buffered
+  - Send: ch <- v
+  - Receive: v := <-ch
+  - Close: close(ch)
+
+patterns:
+  - Don't leak goroutines - ensure they exit
+  - Use context for cancellation
+  - select for multiple channel operations
+  - sync.WaitGroup for goroutine coordination
+```
+
+### 9. Error Handling
+
+```yaml
+principles:
+  - Errors are values, handle them explicitly
+  - Check errors immediately after call
+  - Return errors, don't panic
+  - Add context when propagating: fmt.Errorf("op failed: %w", err)
+
+panic_recover:
+  - Panic for unrecoverable errors only
+  - Library functions should return errors, not panic
+  - Recover only in deferred functions
+  - Convert internal panics to errors at package boundary
+```
+
+### 10. Project Structure
+
+```yaml
+packages:
+  - One package per directory
+  - Package name matches directory name
+  - main package for executables
+  - Avoid circular imports
+
+files:
+  - doc.go for package documentation
+  - _test.go suffix for test files
+  - Group related types and functions
+```
+
+## Application
+
+When writing or reviewing Go code:
+
+1. **Always** run `gofmt` or `goimports`
+2. **Always** handle returned errors
+3. **Prefer** composition over inheritance
+4. **Prefer** small interfaces
+5. **Prefer** channels for goroutine communication
+6. **Avoid** global state
+7. **Avoid** init() when possible
+8. **Document** exported identifiers

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

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