oh-my-customcode 0.1.2 → 0.1.4

package/templates/agents/sw-engineer/language/kotlin-expert/refs/kotlin/idioms.md

@@ -0,0 +1,234 @@
+# Kotlin Idioms
+
+> Source: https://kotlinlang.org/docs/idioms.html
+
+## Data Classes
+
+```kotlin
+data class Customer(val name: String, val email: String)
+```
+
+Provides:
+- `equals()` / `hashCode()`
+- `toString()`: `"Customer(name=John, email=john@example.com)"`
+- `copy()` function
+- `componentN()` functions
+
+## Default Parameter Values
+
+```kotlin
+fun foo(a: Int = 0, b: String = "") { }
+```
+
+## Filtering Collections
+
+```kotlin
+val positives = list.filter { it > 0 }
+
+// or with explicit type
+val positives = list.filter { x -> x > 0 }
+```
+
+## Checking Element Presence
+
+```kotlin
+if ("john@example.com" in emailsList) { }
+if ("jane@example.com" !in emailsList) { }
+```
+
+## String Interpolation
+
+```kotlin
+println("Name: $name")
+println("Age: ${person.age}")
+```
+
+## Instance Checks
+
+```kotlin
+when (x) {
+    is Foo -> ...
+    is Bar -> ...
+    else -> ...
+}
+```
+
+## Read-only Collections
+
+```kotlin
+val list = listOf("a", "b", "c")
+val map = mapOf("a" to 1, "b" to 2, "c" to 3)
+```
+
+## Accessing Maps
+
+```kotlin
+val map = mapOf("a" to 1)
+println(map["a"]) // prints 1
+```
+
+## Traversing Maps
+
+```kotlin
+for ((k, v) in map) {
+    println("$k -> $v")
+}
+```
+
+## Ranges
+
+```kotlin
+for (i in 1..100) { }      // closed range: 1 to 100
+for (i in 1..<100) { }     // half-open: 1 to 99
+for (i in 2..10 step 2) { }
+for (i in 10 downTo 1) { }
+```
+
+## Lazy Property
+
+```kotlin
+val p: String by lazy {
+    // compute the string
+}
+```
+
+## Extension Functions
+
+```kotlin
+fun String.spaceToCamelCase() { }
+"Convert this to camelcase".spaceToCamelCase()
+```
+
+## Singleton
+
+```kotlin
+object Resource {
+    val name = "Name"
+}
+```
+
+## Instantiate Abstract Class
+
+```kotlin
+abstract class MyAbstractClass {
+    abstract fun doSomething()
+}
+
+val myObject = object : MyAbstractClass() {
+    override fun doSomething() { }
+}
+```
+
+## if-not-null Shorthand
+
+```kotlin
+// Simple
+val length = files?.size
+
+// With else
+val length = files?.size ?: 0
+
+// With let
+files?.let {
+    println(it.size)
+}
+```
+
+## Return on when
+
+```kotlin
+fun transform(color: String): Int {
+    return when (color) {
+        "Red" -> 0
+        "Green" -> 1
+        "Blue" -> 2
+        else -> throw IllegalArgumentException("Invalid color")
+    }
+}
+```
+
+## try-catch Expression
+
+```kotlin
+val result = try {
+    count()
+} catch (e: ArithmeticException) {
+    throw IllegalStateException(e)
+}
+```
+
+## if Expression
+
+```kotlin
+val y = if (x == 1) {
+    "one"
+} else if (x == 2) {
+    "two"
+} else {
+    "other"
+}
+```
+
+## Builder-style Usage
+
+```kotlin
+fun arrayOfMinusOnes(size: Int): IntArray {
+    return IntArray(size).apply { fill(-1) }
+}
+```
+
+## Single-expression Functions
+
+```kotlin
+fun theAnswer() = 42
+
+// equivalent to
+fun theAnswer(): Int {
+    return 42
+}
+```
+
+## Call Multiple Methods (with)
+
+```kotlin
+class Turtle {
+    fun penDown()
+    fun penUp()
+    fun turn(degrees: Double)
+    fun forward(pixels: Double)
+}
+
+val myTurtle = Turtle()
+with(myTurtle) {
+    penDown()
+    for (i in 1..4) {
+        forward(100.0)
+        turn(90.0)
+    }
+    penUp()
+}
+```
+
+## Configure Object (apply)
+
+```kotlin
+val myRectangle = Rectangle().apply {
+    length = 4
+    breadth = 5
+    color = 0xFAFAFA
+}
+```
+
+## Swap Variables
+
+```kotlin
+var a = 1
+var b = 2
+a = b.also { b = a }
+```
+
+## TODO: Marking Incomplete
+
+```kotlin
+fun calcTaxes(): BigDecimal = TODO("Waiting for feedback from accounting")
+```

package/templates/agents/sw-engineer/language/kotlin-expert/refs/kotlin/index.yaml

@@ -0,0 +1,26 @@
+# Kotlin Guide
+
+metadata:
+  name: kotlin
+  description: Kotlin language reference documentation
+
+source:
+  type: external
+  origin: kotlinlang.org
+  urls:
+    - https://kotlinlang.org/docs/coding-conventions.html
+    - https://kotlinlang.org/docs/idioms.html
+    - https://developer.android.com/kotlin/style-guide
+  last_fetched: "2026-01-22"
+
+documents:
+  - name: coding-conventions
+    path: ./coding-conventions.md
+    description: Official Kotlin coding conventions
+
+  - name: idioms
+    path: ./idioms.md
+    description: Idiomatic Kotlin patterns
+
+used_by:
+  - kotlin-expert

package/templates/agents/sw-engineer/language/kotlin-expert/refs/kotlin-best-practices/SKILL.md

@@ -0,0 +1,255 @@
+# Kotlin Best Practices Skill
+
+> **Category**: Development
+> **Source**: Internal (based on Kotlin Coding Conventions)
+
+## Purpose
+
+Apply idiomatic Kotlin patterns and best practices from official JetBrains documentation.
+
+## Core Principles
+
+```
+Concise yet readable
+Null safety by design
+Interoperability with Java
+Functional when appropriate
+```
+
+## Rules
+
+### 1. Naming Conventions
+
+```yaml
+packages:
+  style: lowercase, no underscores
+  example: org.example.project
+
+classes_objects:
+  style: UpperCamelCase
+  example: DeclarationProcessor
+
+functions_variables:
+  style: lowerCamelCase
+  example: processDeclarations, declarationCount
+
+constants:
+  style: SCREAMING_SNAKE_CASE
+  example: const val MAX_COUNT = 8
+
+backing_properties:
+  style: underscore prefix
+  example: private val _elementList
+
+acronyms:
+  two_letters: both uppercase (IOStream)
+  three_plus: capitalize first only (XmlFormatter)
+```
+
+### 2. Source File Organization
+
+```yaml
+file_naming:
+  single_class: name after the class (MyClass.kt)
+  multiple_classes: descriptive UpperCamelCase (ProcessDeclarations.kt)
+  platform_specific: add suffix (Platform.jvm.kt)
+
+class_layout:
+  1: Property declarations and initializer blocks
+  2: Secondary constructors
+  3: Method declarations
+  4: Companion object
+
+directory_structure:
+  - Follow package structure with common root omitted
+  - Example: org.example.kotlin.network → network/
+```
+
+### 3. Formatting
+
+```yaml
+indentation:
+  - 4 spaces (no tabs)
+  - Opening brace at end of line
+  - Closing brace on separate line
+
+horizontal_whitespace:
+  around_binary_operators: "a + b"
+  no_around_range: "0..i"
+  no_around_unary: "a++"
+  after_control_keywords: "if (condition)"
+  no_before_parentheses: "method()"
+  never_around_dot: "foo.bar()"
+
+colons:
+  type_supertype: "class Foo : Bar"
+  declaration_type: "val x: Int"
+  always_space_after: true
+
+trailing_commas:
+  recommended: true
+  reason: cleaner diffs, easier reordering
+```
+
+### 4. Functions
+
+```yaml
+expression_bodies:
+  prefer: "fun foo() = 1"
+  over: |
+    fun foo(): Int {
+        return 1
+    }
+
+default_parameters:
+  prefer: "fun foo(a: String = \"a\")"
+  over: overloaded functions
+
+single_line_signatures:
+  if_fits: "fun foo(a: Int): String = ..."
+  otherwise: |
+    fun longMethodName(
+        argument: ArgumentType = defaultValue,
+        argument2: AnotherArgumentType,
+    ): ReturnType { }
+
+unit_return:
+  avoid: "fun foo(): Unit { }"
+  prefer: "fun foo() { }"
+```
+
+### 5. Null Safety
+
+```yaml
+principles:
+  - Prefer non-null types by default
+  - Use ? only when nullability is meaningful
+  - Leverage safe calls (?.) and elvis (?:)
+
+patterns: |
+  // Safe call
+  val length = text?.length
+
+  // Elvis operator
+  val name = user?.name ?: "Anonymous"
+
+  // Let for null checks
+  user?.let {
+      println(it.name)
+  }
+
+  // Not-null assertion (use sparingly)
+  val name = user!!.name
+```
+
+### 6. Idiomatic Patterns
+
+```yaml
+immutability:
+  prefer: "val over var"
+  collections: "listOf() over arrayListOf()"
+
+conditionals:
+  binary: use if
+  multiple: use when
+
+  patterns: |
+    // if expression
+    return if (x) foo() else bar()
+
+    // when expression
+    return when(x) {
+        0 -> "zero"
+        else -> "nonzero"
+    }
+
+functional:
+  prefer: "list.filter { it > 10 }.map { it * 2 }"
+  over: manual loops (except forEach)
+
+ranges:
+  prefer: "for (i in 0..<n)"
+  avoid: "for (i in 0..n - 1)"
+
+type_aliases:
+  use_for: |
+    typealias MouseClickHandler = (Any, MouseEvent) -> Unit
+    typealias PersonIndex = Map<String, Person>
+```
+
+### 7. Lambdas
+
+```yaml
+formatting:
+  - Spaces around curly braces: "list.filter { it > 10 }"
+  - Single lambda outside parentheses
+  - it for single parameter
+
+patterns: |
+  // Outside parentheses
+  list.filter { it > 10 }
+
+  // Multiple parameters
+  list.fold(0) { acc, item -> acc + item }
+
+  // Destructuring
+  map.forEach { (key, value) -> println("$key = $value") }
+```
+
+### 8. Coroutines
+
+```yaml
+principles:
+  - Use suspend functions for async operations
+  - Structured concurrency with scopes
+  - Proper exception handling
+
+patterns: |
+  // Suspend function
+  suspend fun fetchData(): Data {
+      return withContext(Dispatchers.IO) {
+          api.getData()
+      }
+  }
+
+  // Coroutine scope
+  lifecycleScope.launch {
+      val data = fetchData()
+      updateUI(data)
+  }
+
+  // Exception handling
+  try {
+      val result = async { fetchData() }.await()
+  } catch (e: Exception) {
+      handleError(e)
+  }
+```
+
+### 9. Documentation
+
+```yaml
+format: |
+  /**
+   * Returns the absolute value of the given [number].
+   */
+  fun abs(number: Int): Int { ... }
+
+best_practices:
+  - Incorporate parameters into description
+  - Use brackets for parameter references
+  - Use @param/@return only for lengthy descriptions
+```
+
+## Application
+
+When writing or reviewing Kotlin code:
+
+1. **Always** prefer val over var
+2. **Always** use null-safe types appropriately
+3. **Prefer** expression bodies for simple functions
+4. **Prefer** functional operations over loops
+5. **Use** default parameters over overloads
+6. **Use** when for multiple conditions
+7. **Leverage** extension functions
+8. **Document** public APIs

package/templates/agents/sw-engineer/language/kotlin-expert/refs/kotlin-best-practices/index.yaml

@@ -0,0 +1,27 @@
+# Kotlin Best Practices Skill
+
+metadata:
+  name: kotlin-best-practices
+  category: development
+  description: Idiomatic Kotlin patterns from JetBrains conventions
+
+source:
+  type: internal
+  reference:
+    - https://kotlinlang.org/docs/coding-conventions.html
+    - https://kotlinlang.org/docs/idioms.html
+    - https://developer.android.com/kotlin/style-guide
+
+provides:
+  - Kotlin naming conventions
+  - Source file organization
+  - Formatting standards
+  - Function design patterns
+  - Null safety patterns
+  - Idiomatic expressions
+  - Lambda best practices
+  - Coroutine patterns
+  - Documentation guidelines
+
+used_by:
+  - kotlin-expert

package/templates/agents/sw-engineer/language/python-expert/refs/python/index.yaml

@@ -0,0 +1,26 @@
+# Python Guide
+
+metadata:
+  name: python
+  description: Python language reference documentation
+
+source:
+  type: external
+  origin: python.org
+  urls:
+    - https://peps.python.org/pep-0008/
+    - https://peps.python.org/pep-0020/
+    - https://google.github.io/styleguide/pyguide.html
+  last_fetched: "2026-01-22"
+
+documents:
+  - name: pep8-style-guide
+    path: ./pep8-style-guide.md
+    description: PEP 8 - Official Python Style Guide
+
+  - name: zen-of-python
+    path: ./zen-of-python.md
+    description: PEP 20 - The Zen of Python
+
+used_by:
+  - python-expert