oh-my-customcode 0.1.4 → 0.2.0

package/templates/agents/manager/supplier/refs/guides/springboot/best-practices.md

@@ -1,361 +0,0 @@
-# Spring Boot Best Practices
-
-> Source: Spring Documentation and Baeldung
-
-## Project Structure
-
-```
-com.example.app/
-├── controller/          # REST endpoints
-├── service/             # Business logic
-│   └── impl/
-├── repository/          # Data access
-├── model/               # Domain entities
-├── dto/                 # Data transfer objects
-├── config/              # Configuration
-├── exception/           # Custom exceptions
-└── util/                # Utilities
-```
-
-## Dependency Injection
-
-### Constructor Injection (Recommended)
-
-```java
-@Service
-@RequiredArgsConstructor
-public class UserService {
-    private final UserRepository userRepository;
-    private final EmailService emailService;
-}
-```
-
-### Avoid Field Injection
-
-```java
-// NOT RECOMMENDED
-@Service
-public class UserService {
-    @Autowired
-    private UserRepository userRepository;
-}
-```
-
-## REST Controllers
-
-```java
-@RestController
-@RequestMapping("/api/v1/users")
-@RequiredArgsConstructor
-public class UserController {
-
-    private final UserService userService;
-
-    @GetMapping
-    public List<UserResponse> getAllUsers() {
-        return userService.findAll();
-    }
-
-    @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);
-    }
-}
-```
-
-## Service Layer
-
-```java
-public interface UserService {
-    UserResponse findById(Long id);
-    UserResponse create(UserRequest request);
-    UserResponse update(Long id, UserRequest request);
-    void delete(Long id);
-}
-
-@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);
-        User saved = userRepository.save(user);
-        return userMapper.toResponse(saved);
-    }
-}
-```
-
-## Repository Layer
-
-```java
-public interface UserRepository extends JpaRepository<User, Long> {
-
-    Optional<User> findByEmail(String email);
-
-    List<User> findByStatusOrderByCreatedAtDesc(UserStatus status);
-
-    @Query("SELECT u FROM User u WHERE u.department = :dept AND u.status = 'ACTIVE'")
-    List<User> findActiveDepartmentMembers(@Param("dept") String department);
-
-    @Modifying
-    @Query("UPDATE User u SET u.status = :status WHERE u.id = :id")
-    int updateStatus(@Param("id") Long id, @Param("status") UserStatus status);
-}
-```
-
-## Entity Design
-
-```java
-@Entity
-@Table(name = "users")
-@Getter
-@NoArgsConstructor(access = AccessLevel.PROTECTED)
-@EntityListeners(AuditingEntityListener.class)
-public class User {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-
-    @Column(nullable = false, unique = true, length = 100)
-    private String email;
-
-    @Column(nullable = false)
-    private String password;
-
-    @Enumerated(EnumType.STRING)
-    @Column(nullable = false)
-    private UserStatus status = UserStatus.ACTIVE;
-
-    @CreatedDate
-    @Column(updatable = false)
-    private LocalDateTime createdAt;
-
-    @LastModifiedDate
-    private LocalDateTime updatedAt;
-
-    public User(String email, String password) {
-        this.email = email;
-        this.password = password;
-    }
-
-    public void updatePassword(String newPassword) {
-        this.password = newPassword;
-    }
-}
-```
-
-## Exception Handling
-
-```java
-// Custom Exception
-public class UserNotFoundException extends RuntimeException {
-    public UserNotFoundException(Long id) {
-        super("User not found: " + id);
-    }
-}
-
-// Global Handler
-@RestControllerAdvice
-@Slf4j
-public class GlobalExceptionHandler {
-
-    @ExceptionHandler(UserNotFoundException.class)
-    @ResponseStatus(HttpStatus.NOT_FOUND)
-    public ErrorResponse handleUserNotFound(UserNotFoundException ex) {
-        log.warn("User not found: {}", ex.getMessage());
-        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", String.join(", ", errors));
-    }
-
-    @ExceptionHandler(Exception.class)
-    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
-    public ErrorResponse handleGeneral(Exception ex) {
-        log.error("Unexpected error", ex);
-        return new ErrorResponse("INTERNAL_ERROR", "An unexpected error occurred");
-    }
-}
-```
-
-## Configuration
-
-```yaml
-# application.yml
-spring:
-  profiles:
-    active: ${SPRING_PROFILES_ACTIVE:local}
-  datasource:
-    url: ${DATABASE_URL}
-    username: ${DATABASE_USERNAME}
-    password: ${DATABASE_PASSWORD}
-  jpa:
-    hibernate:
-      ddl-auto: validate
-    properties:
-      hibernate:
-        format_sql: true
-        default_batch_fetch_size: 100
-
-logging:
-  level:
-    org.hibernate.SQL: DEBUG
-    org.hibernate.type.descriptor.sql: TRACE
-```
-
-```java
-@Configuration
-@ConfigurationProperties(prefix = "app")
-@Validated
-@Getter
-@Setter
-public class AppProperties {
-
-    @NotBlank
-    private String name;
-
-    @NotNull
-    private Security security = new Security();
-
-    @Getter
-    @Setter
-    public static class Security {
-        private String jwtSecret;
-        private Duration jwtExpiration = Duration.ofHours(24);
-    }
-}
-```
-
-## Security Configuration
-
-```java
-@Configuration
-@EnableWebSecurity
-@RequiredArgsConstructor
-public class SecurityConfig {
-
-    private final JwtAuthenticationFilter jwtFilter;
-
-    @Bean
-    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
-        return http
-            .csrf(AbstractHttpConfigurer::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();
-    }
-
-    @Bean
-    public PasswordEncoder passwordEncoder() {
-        return new BCryptPasswordEncoder();
-    }
-}
-```
-
-## Testing
-
-### Controller Test
-
-```java
-@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")
-                .contentType(MediaType.APPLICATION_JSON))
-            .andExpect(status().isOk())
-            .andExpect(jsonPath("$.id").value(1))
-            .andExpect(jsonPath("$.email").value("test@example.com"));
-    }
-}
-```
-
-### Integration Test
-
-```java
-@SpringBootTest
-@AutoConfigureMockMvc
-@Transactional
-class UserIntegrationTest {
-
-    @Autowired
-    private MockMvc mockMvc;
-
-    @Autowired
-    private UserRepository userRepository;
-
-    @Test
-    void createUser_shouldPersistUser() throws Exception {
-        String request = """
-            {
-                "email": "test@example.com",
-                "password": "password123"
-            }
-            """;
-
-        mockMvc.perform(post("/api/v1/users")
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(request))
-            .andExpect(status().isCreated());
-
-        assertThat(userRepository.findByEmail("test@example.com")).isPresent();
-    }
-}
-```

package/templates/agents/manager/supplier/refs/guides/springboot/index.yaml

@@ -1,22 +0,0 @@
-# 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/manager/supplier/refs/guides/typescript/advanced-types.md

@@ -1,225 +0,0 @@
-# TypeScript Advanced Types
-
-> Reference for advanced TypeScript type patterns
-
-## Utility Types
-
-```typescript
-// Partial - make all properties optional
-type PartialUser = Partial<User>;
-
-// Required - make all properties required
-type RequiredUser = Required<User>;
-
-// Readonly - make all properties readonly
-type ReadonlyUser = Readonly<User>;
-
-// Pick - select specific properties
-type UserName = Pick<User, 'name' | 'email'>;
-
-// Omit - exclude specific properties
-type UserWithoutId = Omit<User, 'id'>;
-
-// Record - create object type with key-value pairs
-type UserMap = Record<string, User>;
-
-// Exclude - exclude types from union
-type NonNullStatus = Exclude<Status | null, null>;
-
-// Extract - extract types from union
-type StringStatus = Extract<Status, string>;
-
-// NonNullable - remove null and undefined
-type DefinedValue = NonNullable<string | null | undefined>;
-
-// ReturnType - get function return type
-type Result = ReturnType<typeof fetchUser>;
-
-// Parameters - get function parameter types
-type Params = Parameters<typeof fetchUser>;
-```
-
-## Mapped Types
-
-```typescript
-// Make all properties optional
-type Optional<T> = {
-  [P in keyof T]?: T[P];
-};
-
-// Make all properties readonly
-type Immutable<T> = {
-  readonly [P in keyof T]: T[P];
-};
-
-// Make all properties nullable
-type Nullable<T> = {
-  [P in keyof T]: T[P] | null;
-};
-
-// Remap keys
-type Getters<T> = {
-  [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P];
-};
-
-// Filter properties by type
-type OnlyStrings<T> = {
-  [P in keyof T as T[P] extends string ? P : never]: T[P];
-};
-```
-
-## Conditional Types
-
-```typescript
-// Basic conditional
-type IsString<T> = T extends string ? true : false;
-
-// With infer
-type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
-
-// Array element type
-type ElementType<T> = T extends (infer E)[] ? E : never;
-
-// Function return type
-type GetReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
-
-// Distributive conditional
-type ToArray<T> = T extends any ? T[] : never;
-// ToArray<string | number> = string[] | number[]
-```
-
-## Template Literal Types
-
-```typescript
-// Simple template
-type Greeting = `Hello, ${string}!`;
-
-// With union
-type EventHandler = `on${Capitalize<'click' | 'hover' | 'focus'>}`;
-// 'onClick' | 'onHover' | 'onFocus'
-
-// Extract from string
-type ExtractRouteParams<T extends string> =
-  T extends `${string}:${infer Param}/${infer Rest}`
-    ? Param | ExtractRouteParams<Rest>
-    : T extends `${string}:${infer Param}`
-    ? Param
-    : never;
-
-// ExtractRouteParams<'/users/:id/posts/:postId'>
-// = 'id' | 'postId'
-```
-
-## Discriminated Unions
-
-```typescript
-interface Circle {
-  kind: 'circle';
-  radius: number;
-}
-
-interface Square {
-  kind: 'square';
-  side: number;
-}
-
-interface Rectangle {
-  kind: 'rectangle';
-  width: number;
-  height: number;
-}
-
-type Shape = Circle | Square | Rectangle;
-
-function getArea(shape: Shape): number {
-  switch (shape.kind) {
-    case 'circle':
-      return Math.PI * shape.radius ** 2;
-    case 'square':
-      return shape.side ** 2;
-    case 'rectangle':
-      return shape.width * shape.height;
-  }
-}
-```
-
-## Index Signatures
-
-```typescript
-// String index
-interface Dictionary {
-  [key: string]: string;
-}
-
-// Number index
-interface NumberMap {
-  [index: number]: string;
-}
-
-// With specific properties
-interface User {
-  id: string;
-  name: string;
-  [key: string]: string; // additional properties
-}
-
-// Template literal index
-type Handlers = {
-  [K in `on${Capitalize<string>}`]: (event: Event) => void;
-};
-```
-
-## Type Narrowing
-
-```typescript
-// Control flow analysis
-function process(value: string | number | null) {
-  if (value === null) {
-    return; // value is null
-  }
-
-  if (typeof value === 'string') {
-    console.log(value.toUpperCase()); // value is string
-  } else {
-    console.log(value.toFixed(2)); // value is number
-  }
-}
-
-// Assertion functions
-function assertIsString(value: unknown): asserts value is string {
-  if (typeof value !== 'string') {
-    throw new Error('Not a string');
-  }
-}
-
-// Type predicates
-function isNonNull<T>(value: T): value is NonNullable<T> {
-  return value !== null && value !== undefined;
-}
-
-const filtered = items.filter(isNonNull);
-```
-
-## Brand Types
-
-```typescript
-// Create distinct types for same underlying type
-type UserId = string & { readonly brand: unique symbol };
-type PostId = string & { readonly brand: unique symbol };
-
-function createUserId(id: string): UserId {
-  return id as UserId;
-}
-
-function createPostId(id: string): PostId {
-  return id as PostId;
-}
-
-function getUser(id: UserId): User { ... }
-
-const userId = createUserId('123');
-const postId = createPostId('456');
-
-getUser(userId); // OK
-getUser(postId); // Error: PostId not assignable to UserId
-```

package/templates/agents/manager/supplier/refs/guides/typescript/index.yaml

@@ -1,26 +0,0 @@
-# TypeScript Guide
-
-metadata:
-  name: typescript
-  description: TypeScript language reference documentation
-
-source:
-  type: external
-  origin: typescriptlang.org
-  urls:
-    - https://www.typescriptlang.org/docs/handbook/
-    - https://google.github.io/styleguide/tsguide.html
-    - https://basarat.gitbook.io/typescript/
-  last_fetched: "2026-01-22"
-
-documents:
-  - name: type-system
-    path: ./type-system.md
-    description: TypeScript type system fundamentals
-
-  - name: advanced-types
-    path: ./advanced-types.md
-    description: Advanced TypeScript type patterns
-
-used_by:
-  - typescript-expert