oh-my-customcode 0.30.8 → 0.31.0

package/README.md

@@ -21,7 +21,7 @@ Like oh-my-zsh transformed shell customization, oh-my-customcode makes personali
 
 | Feature | Description |
 |---------|-------------|
-| **Batteries Included** | 44 agents, 68 skills, 24 guides, 18 rules, 2 hooks, 4 contexts, ontology graph - ready to use out of the box |
+| **Batteries Included** | 44 agents, 68 skills, 25 guides, 18 rules, 2 hooks, 4 contexts, ontology graph - ready to use out of the box |
 | **Sub-Agent Model** | Supports hierarchical agent orchestration with specialized roles |
 | **Dead Simple Customization** | Create a folder + markdown file = new agent or skill |
 | **Mix and Match** | Use built-in components, create your own, or combine both |
@@ -197,7 +197,7 @@ All commands are invoked inside the Claude Code conversation.
 | **Deploy** | 2 | vercel-deploy, codex-exec |
 | **External** | 1 | skills-sh-search |
 
-### Guides (24)
+### Guides (25)
 
 Comprehensive reference documentation covering:
 - Agent creation and management
@@ -292,7 +292,8 @@ your-project/
 │   ├── rules/             # Behavior rules (18 total)
 │   ├── hooks/             # Event hooks (2 total)
 │   └── contexts/          # Context files (4 total)
-└── guides/                # Reference docs (24 total)
+└── templates/
+    └── guides/            # Reference docs (25 total)
 ```
 
 **Note**: In the official Claude Code format, there is no command registry — slash commands and natural language agent references are used.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-customcode",
-  "version": "0.30.8",
+  "version": "0.31.0",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {

package/templates/CLAUDE.md.en

@@ -168,6 +168,7 @@ Violation = immediate correction. No exception for "small changes".
 | `/optimize-analyze` | Analyze bundle and performance |
 | `/optimize-bundle` | Optimize bundle size |
 | `/optimize-report` | Generate optimization report |
+| `/research` | 10-team parallel deep analysis and cross-verification |
 | `/sauron-watch` | Full R017 verification |
 | `/structured-dev-cycle` | 6-stage structured development cycle (Plan → Verify → Implement → Verify → Compound → Done) |
 | `/lists` | Show all available commands |

package/templates/CLAUDE.md.ko

@@ -168,6 +168,7 @@ oh-my-customcode로 구동됩니다.
 | `/optimize-analyze` | 번들 및 성능 분석 |
 | `/optimize-bundle` | 번들 크기 최적화 |
 | `/optimize-report` | 최적화 리포트 생성 |
+| `/research` | 10-team 병렬 딥 분석 및 교차 검증 |
 | `/sauron-watch` | 전체 R017 검증 |
 | `/structured-dev-cycle` | 6단계 구조적 개발 사이클 (Plan → Verify → Implement → Verify → Compound → Done) |
 | `/lists` | 모든 사용 가능한 커맨드 표시 |

package/templates/guides/flutter/performance.md

@@ -80,7 +80,7 @@ Detect with: DevTools → Rendering → "Highlight repaints"
 
 | Avoid | Use Instead | Reason |
 |-------|-------------|--------|
-| `Opacity` widget | `color.withOpacity()` | Triggers saveLayer |
+| `Opacity` widget | `color.withValues(alpha: 0.5)` | Opacity widget triggers saveLayer |
 | `ClipRRect` in animations | Pre-clip static content | saveLayer per frame |
 | `Container` for sizing | `SizedBox` | Lighter, no decoration |
 

package/templates/guides/java21/index.yaml

@@ -0,0 +1,29 @@
+# Java 21 Guide
+
+metadata:
+  name: java21
+  description: Java 21 language reference and modern feature documentation
+
+source:
+  type: external
+  origin: docs.oracle.com
+  urls:
+    - https://docs.oracle.com/en/java/javase/21/
+    - https://openjdk.org/projects/loom/
+    - https://openjdk.org/jeps/440
+    - https://openjdk.org/jeps/441
+    - https://openjdk.org/jeps/444
+    - https://google.github.io/styleguide/javaguide.html
+  last_fetched: "2026-03-11"
+
+documents:
+  - name: modern-java21
+    path: ./modern-java21.md
+    description: Java 21 modern features (Virtual Threads, Pattern Matching, Records, Sealed Classes)
+
+  - name: java-style-guide
+    path: ./java-style-guide.md
+    description: Google Java Style Guide conventions
+
+used_by:
+  - lang-java21-expert

package/templates/guides/java21/java-style-guide.md

@@ -0,0 +1,248 @@
+# Java Style Guide
+
+> Source: https://google.github.io/styleguide/javaguide.html
+
+## File Structure
+
+```
+Source file:
+  1. License/copyright (if any)
+  2. Package statement
+  3. Import statements
+  4. Exactly one top-level class
+```
+
+### Import Ordering
+
+```java
+// 1. Static imports (all together)
+import static org.junit.Assert.assertEquals;
+
+// 2. Non-static imports (all together, no subgroups)
+import com.example.Foo;
+import java.util.List;
+import org.springframework.boot.SpringApplication;
+```
+
+No wildcard imports except `static` test imports.
+
+---
+
+## Naming Conventions
+
+| Element | Style | Example |
+|---------|-------|---------|
+| Packages | `lowercase` | `com.example.network` |
+| Classes | `UpperCamelCase` | `OrderProcessor` |
+| Records | `UpperCamelCase` | `UserRecord` |
+| Methods | `lowerCamelCase` | `processOrder()` |
+| Local vars | `lowerCamelCase` | `itemCount` |
+| Constants | `UPPER_SNAKE_CASE` | `MAX_RETRIES` |
+| Type params | Single letter or `UpperCamelCase + T` | `T`, `E`, `RequestT` |
+
+### Acronyms
+
+Treat acronyms as words: `XmlParser`, not `XMLParser`. Exception: well-known 2-letter ones like `IO`.
+
+---
+
+## Formatting
+
+### Indentation
+
+- 2 spaces (not tabs) for block indentation
+- 4 spaces for line continuation
+
+```java
+// Block indentation: 2 spaces
+if (condition) {
+  doSomething();
+}
+
+// Line continuation: 4 spaces
+String result = longMethodName(
+    argument1,
+    argument2);
+```
+
+### Braces
+
+Always use braces, even for single-statement bodies:
+
+```java
+// Correct
+if (condition) {
+  doSomething();
+}
+
+// Wrong (no braces)
+if (condition)
+  doSomething();
+```
+
+### Column Limit
+
+100 characters per line. Wrap when exceeding.
+
+### Blank Lines
+
+```java
+class MyClass {
+  private int field;          // field
+                              // one blank line
+  public MyClass() { }        // constructor
+                              // one blank line
+  public void method() { }    // method
+}
+```
+
+---
+
+## Class Structure
+
+```java
+public class MyClass {
+  // 1. Static fields
+  private static final Logger log = LoggerFactory.getLogger(MyClass.class);
+
+  // 2. Instance fields
+  private final String name;
+
+  // 3. Constructors
+  public MyClass(String name) {
+    this.name = name;
+  }
+
+  // 4. Static factory methods (if applicable)
+  public static MyClass of(String name) {
+    return new MyClass(name);
+  }
+
+  // 5. Instance methods (public → package → protected → private)
+  public String getName() { return name; }
+
+  private void helper() { }
+
+  // 6. Inner classes/interfaces (last)
+}
+```
+
+---
+
+## Programming Practices
+
+### Annotations
+
+```java
+// One annotation per line for class/method
+@Override
+@Nullable
+public String format(String input) { }
+
+// Multiple short annotations on one line for field is OK
+@Nullable @Deprecated String field;
+```
+
+### Numeric Literals
+
+```java
+long big = 1_000_000L;
+double pi = 3.14_159;
+int hex = 0xFF_EC_D1_8C;
+```
+
+### Switch Expressions (prefer over statements)
+
+```java
+// Prefer switch expression
+int days = switch (month) {
+  case JANUARY, MARCH, MAY, JULY, AUGUST, OCTOBER, DECEMBER -> 31;
+  case APRIL, JUNE, SEPTEMBER, NOVEMBER -> 30;
+  case FEBRUARY -> 28;
+};
+```
+
+### Avoid Long Methods
+
+Keep methods short and focused. Extract helpers for blocks exceeding ~20 lines.
+
+---
+
+## Javadoc
+
+### Required for
+
+- Every `public` class, interface, enum, record
+- Every `public` or `protected` method (unless trivially obvious)
+
+### Format
+
+```java
+/**
+ * Returns the user associated with the given ID.
+ *
+ * <p>This method performs a database lookup. It is safe to call
+ * from multiple threads.
+ *
+ * @param id the user identifier (must be positive)
+ * @return the user, or empty if not found
+ * @throws IllegalArgumentException if {@code id <= 0}
+ */
+public Optional<User> findById(long id) { }
+```
+
+### Inline Tags
+
+```java
+/**
+ * See {@link UserRepository} for persistence details.
+ * Use {@code null} to reset the state.
+ */
+```
+
+### Prohibited: Non-Javadoc Comments for API
+
+```java
+// Wrong: plain comment for public method
+// Returns the user by id
+public Optional<User> findById(long id) { }
+
+// Correct: Javadoc
+/** Returns the user by id, or empty if not found. */
+public Optional<User> findById(long id) { }
+```
+
+---
+
+## Common Antipatterns to Avoid
+
+```java
+// ❌ Raw types
+List list = new ArrayList();
+// ✓
+List<String> list = new ArrayList<>();
+
+// ❌ String concatenation in loop
+String s = "";
+for (String item : items) s += item;
+// ✓
+StringBuilder sb = new StringBuilder();
+for (String item : items) sb.append(item);
+String s = sb.toString();
+
+// ❌ Return null for collections
+public List<String> getItems() { return null; }
+// ✓
+public List<String> getItems() { return Collections.emptyList(); }
+
+// ❌ Catch Exception broadly
+try { process(); } catch (Exception e) { }
+// ✓
+try { process(); } catch (IOException e) { log.error("IO error", e); }
+
+// ❌ Mutable public field
+public String name;
+// ✓
+private String name;
+public String getName() { return name; }
+```

package/templates/guides/java21/modern-java21.md

@@ -0,0 +1,303 @@
+# Modern Java 21 Features
+
+> Sources: https://openjdk.org/jeps/ (JEP 431, 440, 441, 444)
+
+## Virtual Threads (JEP 444)
+
+Virtual Threads are lightweight threads managed by the JVM, enabling millions of concurrent tasks without thread pool tuning.
+
+### Key Properties
+
+| Property | Platform Thread | Virtual Thread |
+|----------|----------------|----------------|
+| Creation cost | High (OS thread) | Low (JVM-managed) |
+| Memory footprint | ~1MB per thread | ~few KB |
+| Blocking behavior | Blocks OS thread | Unmounts carrier thread |
+| Pooling | Needed | Not recommended |
+
+### Usage
+
+```java
+// Virtual Thread executor (preferred for I/O-bound tasks)
+try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
+    List<Future<String>> futures = IntStream.range(0, 10_000)
+        .mapToObj(i -> executor.submit(() -> fetchData(i)))
+        .toList();
+    // all 10,000 tasks run concurrently
+}
+
+// Direct creation
+Thread.ofVirtual().name("vt-worker").start(() -> processRequest());
+
+// Factory for thread pools
+ThreadFactory factory = Thread.ofVirtual().name("worker-", 0).factory();
+```
+
+### Structured Concurrency (JEP 453, Preview)
+
+```java
+try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
+    Future<String> user   = scope.fork(() -> fetchUser(id));
+    Future<String> orders = scope.fork(() -> fetchOrders(id));
+
+    scope.join().throwIfFailed();
+
+    return new UserProfile(user.get(), orders.get());
+}
+```
+
+### Pinning Avoidance
+
+Virtual Threads are **pinned** (cannot unmount) inside `synchronized` blocks. Prefer `ReentrantLock`:
+
+```java
+// Avoid (causes pinning)
+synchronized (lock) {
+    callBlockingIO();
+}
+
+// Prefer
+private final ReentrantLock lock = new ReentrantLock();
+lock.lock();
+try {
+    callBlockingIO();
+} finally {
+    lock.unlock();
+}
+```
+
+---
+
+## Pattern Matching for instanceof (JEP 394)
+
+```java
+// Before Java 16
+if (obj instanceof String) {
+    String s = (String) obj;
+    return s.length();
+}
+
+// Java 21
+if (obj instanceof String s) {
+    return s.length();
+}
+
+// With guard
+if (obj instanceof String s && !s.isEmpty()) {
+    return s.toUpperCase();
+}
+```
+
+---
+
+## Pattern Matching for switch (JEP 441)
+
+```java
+// Type patterns
+String format = switch (obj) {
+    case Integer i -> String.format("int %d", i);
+    case Double d  -> String.format("double %.2f", d);
+    case String s  -> String.format("String '%s'", s);
+    case null      -> "null value";
+    default        -> obj.toString();
+};
+
+// Guarded patterns (when clause)
+String classify = switch (number) {
+    case Integer i when i < 0  -> "negative";
+    case Integer i when i == 0 -> "zero";
+    case Integer i             -> "positive";
+    default -> "non-integer";
+};
+```
+
+---
+
+## Record Classes (JEP 395)
+
+Records are immutable data carriers with auto-generated `equals`, `hashCode`, `toString`, and accessors.
+
+```java
+// Basic record
+record Point(int x, int y) {}
+
+Point p = new Point(3, 4);
+int x = p.x(); // accessor (not getX())
+System.out.println(p); // Point[x=3, y=4]
+
+// Compact constructor (validation)
+record Range(int min, int max) {
+    Range {
+        if (min > max)
+            throw new IllegalArgumentException(
+                "min %d > max %d".formatted(min, max));
+    }
+}
+
+// Custom methods
+record Circle(double radius) {
+    static final double PI = Math.PI;
+
+    double area() { return PI * radius * radius; }
+
+    Circle scale(double factor) { return new Circle(radius * factor); }
+}
+
+// Implementing interface
+interface Describable { String describe(); }
+record Color(int r, int g, int b) implements Describable {
+    public String describe() {
+        return "rgb(%d,%d,%d)".formatted(r, g, b);
+    }
+}
+```
+
+### When to Use Records vs Classes
+
+| Use Record | Use Class |
+|------------|-----------|
+| Pure data containers | Entities with mutable state |
+| DTOs, value objects | Domain objects with lifecycle |
+| API response types | Services, repositories |
+| Config/settings | Mutable builders |
+
+---
+
+## Record Patterns (JEP 440)
+
+Deconstruct records directly in `instanceof` and `switch`:
+
+```java
+// instanceof deconstruction
+if (obj instanceof Point(int x, int y)) {
+    System.out.println("x=" + x + ", y=" + y);
+}
+
+// switch deconstruction
+String describe = switch (shape) {
+    case Circle(double r)             -> "circle r=%.2f".formatted(r);
+    case Rectangle(double w, double h) -> "rect %.1fx%.1f".formatted(w, h);
+    default -> "unknown";
+};
+
+// Nested patterns
+record ColoredPoint(Point point, Color color) {}
+
+if (obj instanceof ColoredPoint(Point(int x, int y), Color(int r, int g, int b))) {
+    System.out.printf("Colored point at (%d,%d) with rgb(%d,%d,%d)%n",
+        x, y, r, g, b);
+}
+```
+
+---
+
+## Sealed Classes (JEP 409)
+
+Sealed classes restrict which classes can implement/extend them, enabling exhaustive pattern matching.
+
+```java
+// 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;
+};
+
+// Sealed class hierarchy (non-record)
+sealed class Vehicle permits Car, Truck, Motorcycle {}
+final class Car extends Vehicle { }
+non-sealed class Truck extends Vehicle { } // allows further subclassing
+```
+
+### Benefits
+
+- Compiler enforces exhaustive handling in `switch`
+- Clear closed type hierarchy in domain model
+- Better than `enum` when subtypes carry different data
+
+---
+
+## Sequenced Collections (JEP 431)
+
+New interfaces: `SequencedCollection`, `SequencedSet`, `SequencedMap`.
+
+```java
+// SequencedCollection
+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"]
+list.removeFirst();             // ["a", "b", "c", "end"]
+
+// Reversed view (live, backed by original)
+List<String> reversed = list.reversed();
+
+// SequencedMap
+LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
+map.put("one", 1);
+map.put("two", 2);
+map.put("three", 3);
+
+Map.Entry<String, Integer> first = map.firstEntry(); // "one"=1
+Map.Entry<String, Integer> last  = map.lastEntry();  // "three"=3
+map.putFirst("zero", 0);       // inserts at front
+SequencedMap<String, Integer> rev = map.reversed();
+```
+
+---
+
+## Migration from Legacy Java
+
+### Replace instanceof chains
+
+```java
+// Legacy (avoid)
+if (obj instanceof String) {
+    return ((String) obj).length();
+} else if (obj instanceof Integer) {
+    return ((Integer) obj).intValue();
+}
+
+// Modern
+return switch (obj) {
+    case String s  -> s.length();
+    case Integer i -> i;
+    default -> -1;
+};
+```
+
+### Replace POJOs with Records
+
+```java
+// Legacy POJO (avoid for pure data)
+public class Point {
+    private final int x, y;
+    public Point(int x, int y) { this.x = x; this.y = y; }
+    public int getX() { return x; }
+    public int getY() { return y; }
+    @Override public boolean equals(Object o) { ... }
+    @Override public int hashCode() { ... }
+    @Override public String toString() { ... }
+}
+
+// Modern Record
+record Point(int x, int y) {}
+```
+
+### Replace thread pools for I/O with Virtual Threads
+
+```java
+// Legacy (avoid for I/O-bound)
+ExecutorService pool = Executors.newFixedThreadPool(200);
+
+// Modern
+ExecutorService pool = Executors.newVirtualThreadPerTaskExecutor();
+```

package/templates/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.30.8",
+  "version": "0.31.0",
   "lastUpdated": "2026-03-09T00:00:00.000Z",
   "components": [
     {
@@ -24,7 +24,7 @@
       "name": "guides",
       "path": "guides",
       "description": "Reference documentation",
-      "files": 24
+      "files": 25
     },
     {
       "name": "hooks",

package/templates/.claude/skills/go-best-practices/CLAUDE.md

@@ -1,9 +0,0 @@
-<claude-mem-context>
-# Recent Activity
-
-### Feb 5, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #8 | 8:07 PM | 🔵 | Skill Definition Structure | ~626 |
-</claude-mem-context>