oh-my-customcode 0.36.2 → 0.37.1

package/templates/.claude/skills/java21-best-practices/SKILL.md

@@ -44,6 +44,8 @@ records:
   example: record Point(int x, int y) {}
 ```
 
+Reference: guides/java21/java-style-guide.md
+
 ### 2. Virtual Threads (JEP 444)
 
 ```yaml
@@ -52,27 +54,10 @@ principles:
   - Avoid pooling Virtual Threads (they are lightweight)
   - Replace thread pools for blocking I/O with Virtual Thread executors
 
-patterns: |
-  // Preferred: Virtual Thread executor
-  try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
-      Future<String> result = executor.submit(() -> fetchFromDB());
-      System.out.println(result.get());
-  }
-
-  // Direct creation
-  Thread vThread = Thread.ofVirtual().start(() -> {
-      // blocking I/O is fine here
-      String data = callExternalApi();
-      process(data);
-  });
-
-  // With structured concurrency (JEP 453, preview)
-  try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
-      Future<String> user = scope.fork(() -> fetchUser(id));
-      Future<List<Order>> orders = scope.fork(() -> fetchOrders(id));
-      scope.join().throwIfFailed();
-      return new UserProfile(user.get(), orders.get());
-  }
+patterns:
+  executor: "Executors.newVirtualThreadPerTaskExecutor()"
+  direct: "Thread.ofVirtual().start(() -> { ... })"
+  structured: "StructuredTaskScope.ShutdownOnFailure() for fork/join"
 
 antipatterns:
   - "Executors.newFixedThreadPool() for I/O tasks — use Virtual Threads instead"
@@ -80,44 +65,23 @@ antipatterns:
   - "synchronized blocks in Virtual Thread code — use ReentrantLock instead"
 ```
 
+Reference: guides/java21/modern-java21.md
+
 ### 3. Pattern Matching
 
 ```yaml
-instanceof_patterns: |
-  // Old style (avoid)
-  if (obj instanceof String) {
-      String s = (String) obj;
-      System.out.println(s.length());
-  }
-
-  // New style (prefer)
-  if (obj instanceof String s) {
-      System.out.println(s.length());
-  }
-
-  // With guard
-  if (obj instanceof String s && s.length() > 5) {
-      System.out.println("Long string: " + s);
-  }
-
-switch_patterns: |
-  // Pattern matching for switch (JEP 441)
-  String result = switch (obj) {
-      case Integer i -> "int " + i;
-      case String s  -> "str " + s;
-      case null      -> "null";
-      default        -> "other " + obj;
-  };
-
-  // With guards (when clause)
-  String label = switch (shape) {
-      case Circle c when c.radius() > 10 -> "large circle";
-      case Circle c                       -> "small circle";
-      case Rectangle r                    -> "rectangle";
-      default                             -> "unknown";
-  };
+instanceof_patterns:
+  rule: "Use pattern variable binding instead of explicit casts"
+  guard: "Combine with && for conditional matching"
+
+switch_patterns:
+  rule: "Pattern matching for switch (JEP 441) — use case Type var syntax"
+  guards: "Use 'when' clause for conditional cases"
+  null_handling: "case null supported in switch"
 ```
 
+Reference: guides/java21/modern-java21.md
+
 ### 4. Records (JEP 395)
 
 ```yaml
@@ -126,59 +90,29 @@ principles:
   - Prefer Records over POJOs with getters/setters for pure data
   - Compact constructors for validation
 
-patterns: |
-  // Basic record
-  record Point(int x, int y) {}
-
-  // With validation (compact constructor)
-  record Range(int min, int max) {
-      Range {
-          if (min > max) throw new IllegalArgumentException(
-              "min %d > max %d".formatted(min, max));
-      }
-  }
-
-  // With custom methods
-  record Circle(double radius) {
-      double area() {
-          return Math.PI * radius * radius;
-      }
-  }
-
-  // Implementing interface
-  interface Shape { double area(); }
-  record Square(double side) implements Shape {
-      public double area() { return side * side; }
-  }
+features:
+  validation: "Compact constructor (no parens) for input validation"
+  methods: "Custom methods allowed alongside auto-generated accessors"
+  interfaces: "Records can implement interfaces"
 
 antipatterns:
   - "Mutable state in records — records are inherently immutable"
   - "Using records for entities with behavior — prefer classes"
 ```
 
+Reference: guides/java21/modern-java21.md
+
 ### 5. Record Patterns (JEP 440)
 
 ```yaml
-patterns: |
-  // Deconstruct record in instanceof
-  if (obj instanceof Point(int x, int y)) {
-      System.out.println("x=" + x + ", y=" + y);
-  }
-
-  // In switch
-  String describe = switch (shape) {
-      case Circle(double r)        -> "circle r=" + r;
-      case Rectangle(double w, double h) -> "rect " + w + "x" + h;
-      default -> "unknown";
-  };
-
-  // Nested record patterns
-  record ColoredPoint(Point point, Color color) {}
-  if (obj instanceof ColoredPoint(Point(int x, int y), Color c)) {
-      System.out.println("colored point at " + x + "," + y);
-  }
+patterns:
+  instanceof: "Deconstruct record components in instanceof check"
+  switch: "Deconstruct in switch case labels"
+  nested: "Nested record patterns for deep destructuring"
 ```
 
+Reference: guides/java21/modern-java21.md
+
 ### 6. Sealed Classes (JEP 409)
 
 ```yaml
@@ -187,21 +121,11 @@ principles:
   - Combine with Pattern Matching switch for exhaustive handling
   - Prefer sealed interfaces for behavior-focused hierarchies
 
-patterns: |
-  // Sealed interface with records
-  sealed interface Shape permits Circle, Rectangle, Triangle {}
-  record Circle(double radius) implements Shape {}
-  record Rectangle(double width, double height) implements Shape {}
-  record Triangle(double base, double height) implements Shape {}
-
-  // Exhaustive switch (no default needed)
-  double area = switch (shape) {
-      case Circle(double r)             -> Math.PI * r * r;
-      case Rectangle(double w, double h) -> w * h;
-      case Triangle(double b, double h)  -> 0.5 * b * h;
-  };
+pattern: "sealed interface with record implementations, exhaustive switch (no default needed)"
 ```
 
+Reference: guides/java21/modern-java21.md
+
 ### 7. Sequenced Collections (JEP 431)
 
 ```yaml
@@ -209,43 +133,21 @@ principles:
   - Use SequencedCollection for ordered access
   - getFirst()/getLast() replace get(0) and get(size-1)
 
-patterns: |
-  // SequencedCollection methods
-  List<String> list = new ArrayList<>(List.of("a", "b", "c"));
-  String first = list.getFirst(); // "a"
-  String last  = list.getLast();  // "c"
-  list.addFirst("z");             // ["z", "a", "b", "c"]
-  list.addLast("end");            // ["z", "a", "b", "c", "end"]
-
-  // Reversed view
-  List<String> reversed = list.reversed();
-
-  // SequencedMap
-  SequencedMap<String, Integer> map = new LinkedHashMap<>();
-  map.put("one", 1);
-  map.put("two", 2);
-  Map.Entry<String, Integer> firstEntry = map.firstEntry(); // "one"=1
+methods: "getFirst(), getLast(), addFirst(), addLast(), reversed(), firstEntry()"
 ```
 
+Reference: guides/java21/modern-java21.md
+
 ### 8. Text Blocks and String Features
 
 ```yaml
-patterns: |
-  // Text blocks (since Java 15)
-  String json = """
-      {
-          "name": "Alice",
-          "age": 30
-      }
-      """;
-
-  // String.formatted() (since Java 15)
-  String msg = "Hello, %s! You are %d years old.".formatted(name, age);
-
-  // String templates (JEP 430, preview in Java 21)
-  // Prefer String.formatted() or MessageFormat for now
+patterns:
+  text_blocks: "Triple-quote \"\"\" for multi-line strings (since Java 15)"
+  formatted: "String.formatted() for template substitution (since Java 15)"
 ```
 
+Reference: guides/java21/modern-java21.md
+
 ### 9. Error Handling
 
 ```yaml
@@ -255,35 +157,16 @@ principles:
   - Never swallow exceptions silently
   - Use specific exception types
 
-patterns: |
-  // Specific exception type
-  public User findUser(long id) {
-      return userRepository.findById(id)
-          .orElseThrow(() -> new UserNotFoundException("User not found: " + id));
-  }
-
-  // Multi-catch
-  try {
-      process();
-  } catch (IOException | SQLException e) {
-      log.error("Data access failed", e);
-      throw new ServiceException("Processing failed", e);
-  }
+patterns:
+  optional: "orElseThrow(() -> new SpecificException(msg)) for missing values"
+  multi_catch: "catch (IOException | SQLException e) for related exceptions"
 ```
 
+Reference: guides/java21/java-style-guide.md
+
 ### 10. Documentation
 
 ```yaml
-format: |
-  /**
-   * Processes the given {@link Order} and returns a {@link Receipt}.
-   *
-   * @param order the order to process (must not be null)
-   * @return the generated receipt
-   * @throws OrderException if the order cannot be fulfilled
-   */
-  public Receipt processOrder(Order order) { }
-
 best_practices:
   - Use @param and @return for public API
   - Link related types with {@link}
@@ -291,6 +174,8 @@ best_practices:
   - Keep Javadoc focused on "what", not "how"
 ```
 
+Reference: guides/java21/java-style-guide.md
+
 ## Application
 
 When writing or reviewing Java 21 code:

package/templates/CLAUDE.md.en

@@ -5,26 +5,7 @@ Powered by oh-my-customcode.
 ---
 ## STOP AND READ BEFORE EVERY RESPONSE
 
-```
-+==================================================================+
-|  MANDATORY CHECK BEFORE RESPONDING:                               |
-|                                                                   |
-|  1. Does my response start with agent identification?             |
-|     +- Agent: {name} ({type})                                     |
-|     +- Task: {description}                                        |
-|                                                                   |
-|  2. Do my tool calls include identification?                      |
-|     [agent-name] -> Tool: {tool}                                  |
-|     [agent-name] -> Target: {path}                                |
-|                                                                   |
-|                                                                   |
-|  3. Am I about to spawn 2+ agents?                               |
-|     YES -> Check R018: Agent Teams may be REQUIRED                |
-|     3+ agents OR review cycle -> Agent Teams (MUST)               |
-|                                                                   |
-|  If NO to any -> FIX IMMEDIATELY before continuing                |
-+==================================================================+
-```
+1. Response starts with agent identification? (R007) 2. Tool calls include identification? (R008) 3. Spawning 2+ agents? Check R018. → If NO to any, FIX IMMEDIATELY
 
 ---
 
@@ -62,51 +43,12 @@ NO EXCEPTIONS. NO EXCUSES.
 
 > **These rules are NON-NEGOTIABLE. Violation = immediate correction required.**
 
-### 1. Agent Identification (ENFORCED)
-```
-EVERY response MUST start with:
-
-+- Agent: {agent-name} ({agent-type})
-+- Skill: {skill-name} (if applicable)
-+- Task: {brief-task-description}
-
-NO EXCEPTIONS. Even for simple questions.
-```
-
-### 2. Tool Usage Identification (ENFORCED)
-```
-EVERY tool call MUST be prefixed with:
-
-[agent-name] -> Tool: <tool-name>
-[agent-name] -> Target: <file/path/url>
-
-Example:
-[lang-golang-expert] -> Tool: Read
-[lang-golang-expert] -> Target: src/main.go
-```
-
-### 3. Parallel Execution (ENFORCED for 2+ independent tasks)
-```
-When 2 or more tasks are INDEPENDENT:
--> MUST spawn parallel agent instances (max 4)
--> MUST NOT process sequentially
-
-Detection: If tasks don't share state or have dependencies -> PARALLEL
-```
-
-### 4. Orchestrator Coordination (ENFORCED for multi-agent tasks)
-```
-When task requires multiple agents:
--> Main conversation (orchestrator) MUST coordinate
--> Main conversation assigns tasks to appropriate agents
--> Main conversation aggregates results
--> Orchestrator MUST NEVER directly modify files
-
-Flow:
-  User -> Main conversation -> [agent-1, agent-2, agent-3] -> Main conversation -> User
-
-Violation = immediate correction. No exception for "small changes".
-```
+| Rule | Core | On Violation |
+|------|------|-------------|
+| R007 Agent ID | Every response starts with `┌─ Agent:` header | Add header immediately |
+| R008 Tool ID | Every tool call prefixed with `[agent][model] → Tool:` | Add prefix immediately |
+| R009 Parallel | 2+ independent tasks → parallel agents (max 4) | Stop sequential, switch to parallel |
+| R010 Orchestrator | Orchestrator never modifies files → delegate to subagents | Stop direct modification, delegate |
 
 ---
 

package/templates/CLAUDE.md.ko

@@ -5,26 +5,7 @@ oh-my-customcode로 구동됩니다.
 ---
 ## 모든 응답 전 반드시 확인
 
-```
-+==================================================================+
-|  응답 전 필수 확인사항:                                           |
-|                                                                   |
-|  1. 내 응답이 에이전트 식별로 시작하는가?                         |
-|     +- Agent: {이름} ({타입})                                     |
-|     +- Task: {설명}                                               |
-|                                                                   |
-|  2. 도구 호출에 식별 정보가 포함되어 있는가?                      |
-|     [에이전트명] -> Tool: {도구}                                  |
-|     [에이전트명] -> Target: {경로}                                |
-|                                                                   |
-|                                                                   |
-|  3. 2개 이상 에이전트를 스폰하려 하는가?                          |
-|     YES -> R018 체크: Agent Teams 필수 여부 확인                  |
-|     3+ 에이전트 OR 리뷰 사이클 -> Agent Teams 필수                |
-|                                                                   |
-|  하나라도 NO면 -> 즉시 수정 후 계속                               |
-+==================================================================+
-```
+1. 에이전트 식별로 시작하는가? (R007) 2. 도구 호출에 식별 포함? (R008) 3. 2+ 에이전트 스폰 시 R018 체크? → 하나라도 NO면 즉시 수정
 
 ---
 
@@ -62,51 +43,12 @@ oh-my-customcode로 구동됩니다.
 
 > **이 규칙들은 협상 불가. 위반 = 즉시 수정 필요.**
 
-### 1. 에이전트 식별 (강제)
-```
-모든 응답은 반드시 다음으로 시작:
-
-+- Agent: {에이전트명} ({에이전트타입})
-+- Skill: {스킬명} (해당 시)
-+- Task: {간단한 작업 설명}
-
-예외 없음. 간단한 질문도 마찬가지.
-```
-
-### 2. 도구 사용 식별 (강제)
-```
-모든 도구 호출은 반드시 에이전트 식별 포함:
-
-[에이전트명] -> Tool: <도구명>
-[에이전트명] -> Target: <파일/경로/URL>
-
-예:
-[lang-golang-expert] -> Tool: Read
-[lang-golang-expert] -> Target: src/main.go
-```
-
-### 3. 병렬 실행 (2개 이상 독립 작업 시 강제)
-```
-2개 이상의 작업이 독립적일 때:
--> 반드시 병렬 에이전트 인스턴스 생성 (최대 4개)
--> 순차 처리 금지
-
-감지: 작업 간 상태 공유나 의존성이 없으면 -> 병렬
-```
-
-### 4. 오케스트레이터 조율 (다중 에이전트 작업 시 강제)
-```
-작업에 여러 에이전트가 필요할 때:
--> 메인 대화 (오케스트레이터)가 반드시 조율
--> 메인 대화가 적절한 에이전트에 작업 할당
--> 메인 대화가 결과 집계
--> 오케스트레이터는 절대 직접 파일을 수정하지 않음
-
-흐름:
-  사용자 -> 메인 대화 -> [agent-1, agent-2, agent-3] -> 메인 대화 -> 사용자
-
-위반 시 즉시 수정. "작은 변경"도 예외 없음.
-```
+| 규칙 | 핵심 | 위반 시 |
+|------|------|--------|
+| R007 에이전트 식별 | 모든 응답은 `┌─ Agent:` 헤더로 시작 | 즉시 헤더 추가 |
+| R008 도구 식별 | 모든 도구 호출에 `[에이전트명][모델] → Tool:` 접두사 | 즉시 접두사 추가 |
+| R009 병렬 실행 | 독립 작업 2개 이상 → 병렬 에이전트 (최대 4개) | 순차 실행 중단, 병렬로 전환 |
+| R010 오케스트레이터 | 오케스트레이터는 파일 수정 금지 → 서브에이전트에 위임 | 직접 수정 중단, 위임 |
 
 ---
 

package/templates/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.36.2",
+  "version": "0.37.1",
   "lastUpdated": "2026-03-14T00:00:00.000Z",
   "components": [
     {