oh-my-customcode 0.1.4 → 0.2.0

package/templates/agents/sw-engineer/backend/springboot-expert/refs/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/sw-engineer/backend/springboot-expert/refs/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/sw-engineer/frontend/svelte-agent/index.yaml

@@ -1,41 +0,0 @@
-# Svelte Agent
-
-metadata:
-  name: svelte-agent
-  type: sw-engineer/frontend
-  description: Expert Svelte developer with compiler-based reactivity and SvelteKit expertise
-
-source:
-  type: internal
-
-capabilities:
-  - Svelte compiler-based reactivity
-  - Reactive statements and stores
-  - Component composition with slots
-  - SvelteKit full-stack development
-  - SSR and SSG strategies
-  - Transitions and animations
-
-skills:
-  - name: svelte-best-practices
-    category: development
-    path: ../../../../skills/development/svelte-best-practices
-
-references:
-  - name: Svelte Documentation
-    url: https://svelte.dev/docs
-  - name: Svelte Tutorial
-    url: https://svelte.dev/tutorial
-  - name: Svelte Reactivity
-    url: https://svelte.dev/docs/svelte-components
-  - name: Svelte Stores
-    url: https://svelte.dev/docs/svelte-store
-  - name: SvelteKit Documentation
-    url: https://kit.svelte.dev/docs
-
-triggers:
-  - "Svelte"
-  - "SvelteKit"
-  - "Svelte store"
-  - "svelte component"
-  - "$: reactive"

package/templates/agents/sw-engineer/frontend/vercel-agent/AGENT.md

@@ -1,67 +0,0 @@
-# Vercel Agent
-
-> **Type**: Worker
-> **Source**: External (GitHub)
-> **Origin**: https://github.com/vercel-labs/agent-skills
-
-## Purpose
-
-Frontend development specialist agent for React/Next.js projects with Vercel deployment capabilities.
-
-## Capabilities
-
-### 1. React/Next.js Optimization
-- Performance optimization with 40+ rules
-- Bundle size optimization
-- Server-side rendering best practices
-- Data fetching patterns
-
-### 2. Web Design Review
-- Accessibility audit (100+ rules)
-- UX/UI best practices
-- ARIA labels and focus states
-- Dark mode, i18n support
-
-### 3. Vercel Deployment
-- Auto-detect 40+ frameworks
-- One-command deployment
-- Preview URL generation
-- Ownership transfer support
-
-## Required Skills
-
-| Skill | Category | Purpose |
-|-------|----------|---------|
-| react-best-practices | development | React/Next.js optimization |
-| web-design-guidelines | development | UI/UX code review |
-| vercel-deploy | development | Deployment automation |
-
-## Workflow
-
-```
-1. Analyze project structure
-2. Apply relevant skill based on task:
-   - Code review → web-design-guidelines
-   - Performance → react-best-practices
-   - Deploy → vercel-deploy
-3. Execute skill instructions
-4. Report results
-```
-
-## Usage Triggers
-
-- "Optimize React performance"
-- "Review UI code"
-- "Check accessibility"
-- "Deploy to Vercel"
-- "Audit bundle size"
-
-## Update
-
-```bash
-# Check for updates
-# Origin: https://github.com/vercel-labs/agent-skills/releases
-
-# Update command
-npx add-skill vercel-labs/agent-skills
-```

package/templates/agents/sw-engineer/frontend/vercel-agent/index.yaml

@@ -1,43 +0,0 @@
-# Vercel Agent
-# External agent from vercel-labs/agent-skills
-
-metadata:
-  name: vercel-agent
-  type: sw-engineer/frontend
-  description: Frontend development agent with React/Next.js optimization, web design review, and Vercel deployment capabilities
-
-source:
-  type: external
-  origin: github
-  url: https://github.com/vercel-labs/agent-skills
-  version: "1.0.0"
-  last_updated: "2025-01-22"
-  update_command: "npx add-skill vercel-labs/agent-skills"
-  changelog_url: https://github.com/vercel-labs/agent-skills/releases
-
-skills:
-  - name: react-best-practices
-    category: development
-    path: ../../../../skills/development/react-best-practices
-
-  - name: web-design-guidelines
-    category: development
-    path: ../../../../skills/development/web-design-guidelines
-
-  - name: vercel-deploy
-    category: development
-    path: ../../../../skills/development/vercel-deploy
-
-capabilities:
-  - React/Next.js performance optimization
-  - UI code review (accessibility, UX)
-  - Vercel deployment automation
-  - Bundle size optimization
-  - Web design best practices
-
-triggers:
-  - "React optimization"
-  - "UI review"
-  - "Deploy to Vercel"
-  - "Performance check"
-  - "Accessibility audit"

package/templates/agents/sw-engineer/frontend/vercel-agent/refs/react-best-practices/SKILL.md

@@ -1,100 +0,0 @@
-# React Best Practices
-
-> **Source**: vercel-labs/agent-skills
-> **Rules**: 40+ rules in 8 categories
-
-## When to Use
-
-- Writing React/Next.js components
-- Data fetching implementation
-- Performance review
-- Bundle size optimization
-
-## Categories by Priority
-
-### Critical Priority
-
-#### Waterfall Elimination
-```
-- Avoid sequential data fetching
-- Use parallel data fetching
-- Implement proper loading states
-- Prefetch critical data
-```
-
-#### Bundle Optimization
-```
-- Minimize client-side JavaScript
-- Use dynamic imports
-- Tree-shake unused code
-- Analyze bundle with tools
-```
-
-### High Priority
-
-#### Server-Side Performance
-```
-- Use Server Components by default
-- Minimize 'use client' directives
-- Implement streaming where possible
-- Cache server responses
-```
-
-### Medium-High Priority
-
-#### Client-Side Fetching
-```
-- Use SWR or React Query
-- Implement optimistic updates
-- Handle loading/error states
-- Cache API responses
-```
-
-### Medium Priority
-
-#### Rendering
-```
-- Avoid unnecessary re-renders
-- Use React.memo strategically
-- Implement useMemo/useCallback properly
-- Virtualize long lists
-```
-
-#### Caching
-```
-- Implement proper cache headers
-- Use ISR for dynamic content
-- Cache database queries
-- CDN caching strategies
-```
-
-#### Code Splitting
-```
-- Split by route
-- Lazy load below-fold content
-- Dynamic import heavy libraries
-- Preload critical chunks
-```
-
-### Low-Medium Priority
-
-#### Image Optimization
-```
-- Use next/image
-- Implement proper sizing
-- Use modern formats (WebP, AVIF)
-- Lazy load off-screen images
-```
-
-## Execution Flow
-
-```
-1. Identify optimization area
-2. Check relevant category rules
-3. Apply recommendations
-4. Verify improvements
-```
-
-## Scripts
-
-See `scripts/` directory for automation helpers.

package/templates/agents/sw-engineer/frontend/vercel-agent/refs/react-best-practices/index.yaml

@@ -1,39 +0,0 @@
-# React Best Practices Skill
-
-metadata:
-  name: react-best-practices
-  category: development
-  description: React/Next.js performance optimization with 40+ rules in 8 categories
-
-source:
-  type: external
-  origin: github
-  url: https://github.com/vercel-labs/agent-skills
-  path: skills/react-best-practices
-  version: "1.0.0"
-  last_updated: "2025-01-22"
-
-triggers:
-  - "optimize React"
-  - "performance review"
-  - "bundle size"
-  - "data fetching"
-  - "Next.js optimization"
-
-categories:
-  - name: waterfall-elimination
-    priority: critical
-  - name: bundle-optimization
-    priority: critical
-  - name: server-performance
-    priority: high
-  - name: client-fetching
-    priority: medium-high
-  - name: rendering
-    priority: medium
-  - name: caching
-    priority: medium
-  - name: code-splitting
-    priority: medium
-  - name: image-optimization
-    priority: low-medium