oh-my-customcode 0.1.2 → 0.1.4

package/templates/agents/sw-engineer/backend/springboot-expert/refs/springboot/index.yaml

@@ -0,0 +1,22 @@
+# Spring Boot Guide
+
+metadata:
+  name: springboot
+  description: Spring Boot framework reference documentation
+
+source:
+  type: external
+  origin: spring.io
+  urls:
+    - https://docs.spring.io/spring-boot/docs/current/reference/html/
+    - https://spring.io/guides
+    - https://www.baeldung.com/spring-boot
+  last_fetched: "2026-01-22"
+
+documents:
+  - name: best-practices
+    path: ./best-practices.md
+    description: Spring Boot best practices and patterns
+
+used_by:
+  - springboot-expert

package/templates/agents/sw-engineer/backend/springboot-expert/refs/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/agents/sw-engineer/backend/springboot-expert/refs/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/agents/sw-engineer/frontend/vercel-agent/refs/react-best-practices/SKILL.md

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

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

package/templates/agents/sw-engineer/frontend/vercel-agent/refs/vercel-deploy/SKILL.md

@@ -0,0 +1,73 @@
+# Vercel Deploy
+
+> **Source**: vercel-labs/agent-skills
+> **Capability**: Instant deployment to Vercel
+
+## When to Use
+
+- Deploy application to Vercel
+- Create preview deployments
+- Generate shareable URLs
+
+## Features
+
+### Framework Detection
+```
+Auto-detects 40+ frameworks from package.json:
+- Next.js
+- React
+- Vue
+- Nuxt
+- Svelte
+- Astro
+- and more...
+```
+
+### Auto Exclusions
+```
+Automatically excludes:
+- node_modules/
+- .git/
+- .env files
+```
+
+### Output
+```
+On successful deployment:
+1. Preview URL (view deployment)
+2. Claim URL (transfer ownership)
+```
+
+## Execution Flow
+
+```
+1. Detect project framework
+2. Prepare deployment bundle
+3. Upload to Vercel
+4. Return URLs
+```
+
+## Output Format
+
+```
+[Deploy Success]
+Preview: https://project-xxx.vercel.app
+Claim: https://vercel.com/claim/xxx
+```
+
+## Scripts
+
+See `scripts/deploy.sh` for deployment automation.
+
+## Requirements
+
+- Valid project structure
+- package.json present
+- Vercel CLI or API token (for authenticated deploys)
+
+## Limitations
+
+- Claimable deploys are anonymous
+- Preview URLs are temporary
+- Full features require Vercel account
+```

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

@@ -0,0 +1,30 @@
+# Vercel Deploy Skill
+
+metadata:
+  name: vercel-deploy
+  category: development
+  description: Deploy applications to Vercel with auto-detection and preview URLs
+
+source:
+  type: external
+  origin: github
+  url: https://github.com/vercel-labs/agent-skills
+  path: skills/vercel-deploy-claimable
+  version: "1.0.0"
+  last_updated: "2025-01-22"
+
+triggers:
+  - "deploy to Vercel"
+  - "create preview"
+  - "publish site"
+  - "Vercel deployment"
+
+capabilities:
+  - Auto-detect 40+ frameworks
+  - Generate preview URLs
+  - Ownership transfer links
+  - Exclude node_modules, .git automatically
+
+requirements:
+  - Vercel CLI or API access
+  - Project with package.json

package/templates/agents/sw-engineer/frontend/vercel-agent/refs/web-design/accessibility.md

@@ -0,0 +1,66 @@
+# Accessibility Best Practices
+
+> Reference guide for web-design-guidelines skill
+
+## Core Principles
+
+### WCAG 2.1 Compliance
+```
+Level A: Minimum accessibility
+Level AA: Standard compliance (recommended)
+Level AAA: Enhanced accessibility
+```
+
+### POUR Principles
+```
+Perceivable: Content available to senses
+Operable: Interface navigable
+Understandable: Clear and predictable
+Robust: Works across technologies
+```
+
+## Quick Reference
+
+### Color Contrast
+```
+Normal text: 4.5:1 minimum
+Large text: 3:1 minimum
+UI components: 3:1 minimum
+```
+
+### Keyboard Navigation
+```
+Tab: Move forward
+Shift+Tab: Move backward
+Enter/Space: Activate
+Escape: Close/Cancel
+Arrow keys: Navigate within component
+```
+
+### ARIA Landmarks
+```html
+<header role="banner">
+<nav role="navigation">
+<main role="main">
+<aside role="complementary">
+<footer role="contentinfo">
+```
+
+### Common ARIA Attributes
+```html
+aria-label="Description"
+aria-labelledby="element-id"
+aria-describedby="description-id"
+aria-hidden="true|false"
+aria-expanded="true|false"
+aria-selected="true|false"
+aria-live="polite|assertive"
+```
+
+## Testing Tools
+
+- axe DevTools
+- WAVE
+- Lighthouse
+- VoiceOver (macOS)
+- NVDA (Windows)