opencode-skills-collection 3.0.49 → 3.0.51

package/bundled-skills/super-code/java/SKILL.md

@@ -0,0 +1,230 @@
+---
+name: java
+description: "Language-specific super-code guidelines for java."
+risk: safe
+source: community
+date_added: "2026-06-16"
+---
+# Java: Idiomatic Efficiency Reference
+
+## Table of Contents
+1. [Streams & Collections](#streams)
+2. [Optional](#optional)
+3. [Records & Data Classes](#records)
+4. [Switch Expressions](#switch)
+5. [Concurrency](#concurrency)
+6. [Error Handling](#errors)
+7. [Anti-patterns specific to Java](#antipatterns)
+
+---
+
+## 1. Streams & Collections {#streams}
+
+```java
+// ❌ Imperative accumulation
+List<String> result = new ArrayList<>();
+for (Item item : items) {
+    if (item.isActive()) result.add(item.getName().toUpperCase());
+}
+
+// ✅
+List<String> result = items.stream()
+    .filter(Item::isActive)
+    .map(item -> item.getName().toUpperCase())
+    .toList(); // Java 16+; use .collect(Collectors.toList()) before
+```
+
+```java
+// ❌ Manual grouping
+Map<String, List<Item>> grouped = new HashMap<>();
+for (Item item : items) {
+    grouped.computeIfAbsent(item.getCategory(), k -> new ArrayList<>()).add(item);
+}
+
+// ✅
+Map<String, List<Item>> grouped = items.stream()
+    .collect(Collectors.groupingBy(Item::getCategory));
+```
+
+```java
+// ❌ Manual sum
+int total = 0;
+for (Order o : orders) total += o.getAmount();
+
+// ✅
+int total = orders.stream().mapToInt(Order::getAmount).sum();
+```
+
+**Prefer method references (`Item::isActive`) over equivalent lambdas (`item -> item.isActive()`).**
+
+---
+
+## 2. Optional {#optional}
+
+```java
+// ❌ Null check chain
+String city = null;
+if (user != null && user.getAddress() != null) {
+    city = user.getAddress().getCity();
+}
+
+// ✅
+String city = Optional.ofNullable(user)
+    .map(User::getAddress)
+    .map(Address::getCity)
+    .orElse(null);
+```
+
+```java
+// ❌ Optional.get() without isPresent()
+String name = optional.get(); // throws if empty
+
+// ✅
+String name = optional.orElse("default");
+// or: optional.orElseThrow(() -> new IllegalStateException("name required"));
+```
+
+```java
+// ❌ Optional as a field or parameter (anti-pattern)
+class User { private Optional<String> nickname; }
+
+// ✅ — Optional is for return types only
+class User { private String nickname; } // nullable field
+public Optional<String> getNickname() { return Optional.ofNullable(nickname); }
+```
+
+---
+
+## 3. Records & Data Classes {#records}
+
+```java
+// ❌ Manual POJO
+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; }
+    // + equals, hashCode, toString...
+}
+
+// ✅ (Java 16+)
+record Point(int x, int y) {}
+```
+
+```java
+// ❌ Builder pattern for a 2-field object
+User user = new User.Builder().name("Alice").age(30).build();
+
+// ✅ — use record or constructor directly for small objects
+record User(String name, int age) {}
+var user = new User("Alice", 30);
+```
+
+**Use `record` for any immutable data carrier. Keep builders only for objects with many optional fields.**
+
+---
+
+## 4. Switch Expressions {#switch}
+
+```java
+// ❌ Switch statement with fall-through and break
+String label;
+switch (status) {
+    case ACTIVE: label = "Active"; break;
+    case INACTIVE: label = "Inactive"; break;
+    default: label = "Unknown";
+}
+
+// ✅ (Java 14+)
+String label = switch (status) {
+    case ACTIVE -> "Active";
+    case INACTIVE -> "Inactive";
+    default -> "Unknown";
+};
+```
+
+```java
+// ❌ instanceof + cast
+if (shape instanceof Circle) {
+    Circle c = (Circle) shape;
+    return c.radius() * c.radius() * Math.PI;
+}
+
+// ✅ Pattern matching (Java 16+)
+if (shape instanceof Circle c) {
+    return c.radius() * c.radius() * Math.PI;
+}
+```
+
+---
+
+## 5. Concurrency {#concurrency}
+
+```java
+// ❌ Raw Thread creation
+Thread t = new Thread(() -> doWork());
+t.start();
+
+// ✅
+ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor(); // Java 21
+exec.submit(() -> doWork());
+```
+
+```java
+// ❌ synchronized on this for fine-grained state
+synchronized(this) { counter++; }
+
+// ✅
+AtomicInteger counter = new AtomicInteger();
+counter.incrementAndGet();
+```
+
+**Prefer `CompletableFuture.allOf()` over blocking `.get()` chains for parallel async work.**
+
+---
+
+## 6. Error Handling {#errors}
+
+```java
+// ❌ Catching Exception to log and swallow
+try {
+    risky();
+} catch (Exception e) {
+    log.error("error", e);
+}
+
+// ✅ — rethrow as unchecked if you can't handle it
+try {
+    risky();
+} catch (IOException e) {
+    throw new UncheckedIOException(e);
+}
+```
+
+```java
+// ❌ Checked exceptions declared on every method
+public void process() throws IOException, SQLException, ParseException { ... }
+
+// ✅ — wrap at the boundary; internal methods throw unchecked
+```
+
+---
+
+## 7. Anti-patterns specific to Java {#antipatterns}
+
+| Anti-pattern | Preferred |
+|---|---|
+| `new ArrayList<String>()` (Java 7+) | `new ArrayList<>()` (diamond) |
+| `"string".equals(variable)` (Yoda) | `Objects.equals(variable, "string")` |
+| `for (int i = 0; i < list.size(); i++)` | enhanced for or stream |
+| `StringBuffer` in single-threaded code | `StringBuilder` |
+| `e.printStackTrace()` | `log.error("msg", e)` |
+| `null` return for "not found" | `Optional<T>` return type |
+| Public fields | private + accessor, or `record` |
+| Mutable `static` fields | avoid; use dependency injection |
+| `instanceof` + cast without pattern matching | pattern matching (Java 16+) |
+
+
+## Limitations
+- These are language-specific guidelines and do not cover overall architectural decisions.
+- Over-compression might reduce readability; apply judgement.

package/bundled-skills/super-code/kotlin/SKILL.md

@@ -0,0 +1,281 @@
+---
+name: kotlin
+description: "Language-specific super-code guidelines for kotlin."
+risk: safe
+source: community
+date_added: "2026-06-16"
+---
+# Kotlin + Compose: Idiomatic Efficiency Reference
+
+## Table of Contents
+1. [Collections & Data Transformation](#collections)
+2. [Null Safety](#null-safety)
+3. [Functions & Lambdas](#functions)
+4. [Classes & Objects](#classes)
+5. [Coroutines & Flow](#coroutines)
+6. [Compose UI](#compose)
+7. [Anti-patterns specific to Kotlin](#antipatterns)
+
+---
+
+## 1. Collections & Data Transformation {#collections}
+
+**Prefer scope functions and stdlib transforms over imperative loops.**
+
+```kotlin
+// ❌ Verbose
+val result = mutableListOf<String>()
+for (item in items) {
+    if (item.isActive) {
+        result.add(item.name.uppercase())
+    }
+}
+
+// ✅ Idiomatic
+val result = items.filter { it.isActive }.map { it.name.uppercase() }
+```
+
+```kotlin
+// ❌ Manual grouping
+val map = mutableMapOf<String, MutableList<Item>>()
+for (item in items) {
+    map.getOrPut(item.category) { mutableListOf() }.add(item)
+}
+
+// ✅
+val map = items.groupBy { it.category }
+```
+
+```kotlin
+// ❌ Manual fold
+var total = 0
+for (order in orders) total += order.amount
+
+// ✅
+val total = orders.sumOf { it.amount }
+```
+
+**Use `associate`, `associateBy`, `partition`, `flatMap`, `zip` instead of manual equivalents.**
+
+---
+
+## 2. Null Safety {#null-safety}
+
+```kotlin
+// ❌ Unnecessary null check when Elvis suffices
+val name: String
+if (user?.name != null) {
+    name = user.name
+} else {
+    name = "Guest"
+}
+
+// ✅
+val name = user?.name ?: "Guest"
+```
+
+```kotlin
+// ❌ Double null check
+if (response != null && response.body != null) {
+    process(response.body!!)
+}
+
+// ✅
+response?.body?.let { process(it) }
+```
+
+```kotlin
+// ❌ !! without guard
+val value = nullable!!.doSomething()
+
+// ✅ Make the non-null contract explicit at the boundary
+val value = requireNotNull(nullable) { "nullable must be set before calling X" }.doSomething()
+// Or return early:
+val n = nullable ?: return
+```
+
+---
+
+## 3. Functions & Lambdas {#functions}
+
+```kotlin
+// ❌ Single-expression function with unnecessary block body
+fun double(x: Int): Int {
+    return x * 2
+}
+
+// ✅
+fun double(x: Int) = x * 2
+```
+
+```kotlin
+// ❌ Lambda capturing unused parameter
+items.forEach { item -> doSomething() }
+
+// ✅
+items.forEach { doSomething() }
+```
+
+```kotlin
+// ❌ Redundant with/apply nesting
+val builder = Builder()
+builder.setName("x")
+builder.setAge(1)
+val result = builder.build()
+
+// ✅
+val result = Builder().apply {
+    setName("x")
+    setAge(1)
+}.build()
+```
+
+**Prefer `let`, `run`, `apply`, `also`, `with` over repeated receiver references — but don't nest more than 2 levels deep.**
+
+---
+
+## 4. Classes & Objects {#classes}
+
+```kotlin
+// ❌ Mutable class for immutable data
+class Point {
+    var x: Int = 0
+    var y: Int = 0
+}
+
+// ✅
+data class Point(val x: Int, val y: Int)
+```
+
+```kotlin
+// ❌ Companion object just to hold a constant
+class Foo {
+    companion object {
+        val TAG = "Foo"
+    }
+}
+
+// ✅ — top-level if only used in this file
+private const val TAG = "Foo"
+class Foo
+```
+
+```kotlin
+// ❌ Enum with when that has to be updated in two places
+enum class Status { ACTIVE, INACTIVE }
+fun label(s: Status) = when(s) { Status.ACTIVE -> "Active"; Status.INACTIVE -> "Inactive" }
+
+// ✅ — put display logic on the enum itself
+enum class Status(val label: String) { ACTIVE("Active"), INACTIVE("Inactive") }
+```
+
+**Sealed classes/interfaces over enum when variants carry different data.**
+
+---
+
+## 5. Coroutines & Flow {#coroutines}
+
+```kotlin
+// ❌ Unnecessary async/await pair when result is used immediately
+val result = async { fetchData() }.await()
+
+// ✅
+val result = fetchData() // just suspend fun, no async needed
+```
+
+```kotlin
+// ❌ Collecting in a loop
+while (true) {
+    val value = channel.receive()
+    process(value)
+}
+
+// ✅
+channel.consumeEach { process(it) }
+// or for Flow:
+flow.collect { process(it) }
+```
+
+```kotlin
+// ❌ StateFlow + manual emit boilerplate
+private val _state = MutableStateFlow(initial)
+val state: StateFlow<State> = _state
+// ... in many places: _state.value = newValue
+
+// ✅ — use update{} for atomic mutation
+_state.update { it.copy(field = newValue) }
+```
+
+**Don't launch coroutines in constructors or init blocks. Don't use GlobalScope.**
+
+---
+
+## 6. Compose UI {#compose}
+
+```kotlin
+// ❌ Unnecessary remember for derived state that's cheap to compute
+val displayName = remember { user.firstName + " " + user.lastName }
+
+// ✅ — only remember if computation is expensive or involves object creation
+val displayName = "${user.firstName} ${user.lastName}"
+```
+
+```kotlin
+// ❌ Passing entire state object when composable only needs one field
+@Composable
+fun UserBadge(user: User) { Text(user.name) }
+
+// ✅ — pass only what's needed (stability + minimal recomposition)
+@Composable
+fun UserBadge(name: String) { Text(name) }
+```
+
+```kotlin
+// ❌ Inline click handler lambda (creates new instance each recomposition)
+Button(onClick = { viewModel.onSave() }) { ... }
+
+// ✅
+val onSave = remember { { viewModel.onSave() } }
+Button(onClick = onSave) { ... }
+// Or pass it down as a parameter already
+```
+
+```kotlin
+// ❌ Nested Column/Row just to group children
+Column {
+    Column {
+        Text("a")
+        Text("b")
+    }
+}
+
+// ✅
+Column {
+    Text("a")
+    Text("b")
+}
+```
+
+**Use `LazyColumn`/`LazyRow` for lists of unknown or large size. Never put a `LazyColumn` inside a `Column` with unbounded height.**
+
+---
+
+## 7. Anti-patterns specific to Kotlin {#antipatterns}
+
+| Anti-pattern | Preferred |
+|---|---|
+| `if (x == true)` | `if (x)` |
+| `if (x == null) return else x!!` | `val x = x ?: return` |
+| `listOf().toMutableList()` for a known-size list | `mutableListOf()` |
+| `when` with a single branch and else | `if/else` |
+| `.toString()` on a string | remove it |
+| Explicit `Unit` return type on functions | omit (inferred) |
+| `object : Runnable { override fun run() { ... } }` | `Runnable { ... }` (SAM) |
+| `@JvmStatic` in pure Kotlin code | only needed for Java interop |
+| Wrapping every function in try/catch to log | handle at the boundary, not inside |
+
+
+
+## Limitations
+- These are language-specific guidelines and do not cover overall architectural decisions.
+- Over-compression might reduce readability; apply judgement.