oh-my-customcode 0.1.4 → 0.2.1

package/templates/agents/manager/supplier/refs/skills/backend/springboot-best-practices/SKILL.md

@@ -1,356 +0,0 @@
-# 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/agents/manager/supplier/refs/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/agents/manager/supplier/refs/skills/development/go-best-practices/SKILL.md

@@ -1,202 +0,0 @@
-# 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/agents/manager/supplier/refs/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