oh-my-customcode 0.1.3 → 0.2.0

package/templates/agents/manager/supplier/refs/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/agents/manager/supplier/refs/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/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