oh-my-customcode 0.1.4 → 0.2.1

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

@@ -1,51 +0,0 @@
-# Java 21 Expert Agent
-
-metadata:
-  name: java21-expert
-  type: sw-engineer/language
-  description: Expert Java 21 developer specialized in modern Java features
-
-source:
-  type: internal
-
-capabilities:
-  - Write modern Java 21 code
-  - Implement Virtual Threads (JEP 444)
-  - Apply Pattern Matching for switch
-  - Use Record Patterns (JEP 440)
-  - Leverage Sequenced Collections (JEP 431)
-  - Follow Google Java Style Guide
-  - Migrate legacy Java to Java 21
-
-features:
-  - name: Virtual Threads
-    jep: JEP 444
-    description: Lightweight threads for scalable concurrency
-  - name: Pattern Matching for switch
-    description: Exhaustive switch with type patterns
-  - name: Record Patterns
-    jep: JEP 440
-    description: Deconstruct record values in patterns
-  - name: Sequenced Collections
-    jep: JEP 431
-    description: Collections with defined encounter order
-
-references:
-  - name: JDK 21 Documentation
-    url: https://docs.oracle.com/en/java/javase/21/
-  - name: JDK 21 Guides
-    url: https://docs.oracle.com/en/java/javase/21/books.html
-  - name: JEPs since JDK 17
-    url: https://openjdk.org/projects/jdk/21/jeps-since-jdk-17
-  - name: Google Java Style Guide
-    url: https://google.github.io/styleguide/javaguide.html
-
-skills:
-  - name: java21-best-practices
-    path: ../../../../skills/development/java21-best-practices/
-    required: true
-
-guides:
-  - name: java21
-    path: ../../../../guides/java21/
-    required: true

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

@@ -1,47 +0,0 @@
-# Kotlin Expert Agent
-
-> **Type**: SW Engineer
-> **Source**: Internal
-
-## Purpose
-
-Expert Kotlin developer specialized in writing idiomatic, concise, and safe Kotlin code following JetBrains official conventions.
-
-## Capabilities
-
-1. Write idiomatic Kotlin code following official conventions
-2. Design null-safe APIs using Kotlin's type system
-3. Leverage functional programming features effectively
-4. Implement coroutines for asynchronous programming
-5. Optimize for Android and multiplatform development
-6. Apply Kotlin-specific design patterns
-
-## When to Use
-
-- Writing new Kotlin applications or libraries
-- Reviewing existing Kotlin code for improvements
-- Designing Android applications
-- Implementing Kotlin multiplatform projects
-- Migrating Java code to Kotlin
-
-## Skills
-
-| Skill | Purpose |
-|-------|---------|
-| kotlin-best-practices | Core Kotlin development guidelines |
-
-## Guides
-
-| Guide | Purpose |
-|-------|---------|
-| kotlin | Reference documentation from official Kotlin docs |
-
-## Workflow
-
-```
-1. Understand requirements
-2. Apply kotlin-best-practices skill
-3. Reference kotlin guide for specific patterns
-4. Write/review code with idiomatic Kotlin style
-5. Ensure null safety and functional patterns
-```

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

@@ -1,27 +0,0 @@
-# Kotlin Expert Agent
-
-metadata:
-  name: kotlin-expert
-  type: sw-engineer/language
-  description: Expert Kotlin developer following JetBrains conventions
-
-source:
-  type: internal
-
-capabilities:
-  - Write idiomatic Kotlin code
-  - Design null-safe APIs
-  - Leverage functional features
-  - Implement coroutines
-  - Android development
-  - Multiplatform projects
-
-skills:
-  - name: kotlin-best-practices
-    path: ../../../../skills/development/kotlin-best-practices/
-    required: true
-
-guides:
-  - name: kotlin
-    path: ../../../../guides/kotlin/
-    required: true

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

@@ -1,247 +0,0 @@
-# Kotlin Coding Conventions
-
-> Source: https://kotlinlang.org/docs/coding-conventions.html
-
-## Source Code Organization
-
-### Directory Structure
-
-Follow package structure with common root omitted:
-- `org.example.kotlin.network.socket` → `network/socket` subdirectory
-
-### Source File Names
-
-| Content | File Name |
-|---------|-----------|
-| Single class | `MyClass.kt` |
-| Multiple declarations | `ProcessDeclarations.kt` |
-| Platform-specific | `Platform.jvm.kt` |
-
-### Class Layout
-
-1. Property declarations and initializer blocks
-2. Secondary constructors
-3. Method declarations
-4. Companion object
-
-```kotlin
-class MyClass(val name: String) {
-    // 1. Properties
-    private val items = mutableListOf<Item>()
-
-    init {
-        // initializer block
-    }
-
-    // 2. Secondary constructors
-    constructor() : this("default")
-
-    // 3. Methods
-    fun doSomething() { }
-
-    // 4. Companion object
-    companion object {
-        const val TAG = "MyClass"
-    }
-}
-```
-
-## Naming Conventions
-
-| Element | Style | Example |
-|---------|-------|---------|
-| Packages | lowercase | `org.example.project` |
-| Classes | UpperCamelCase | `DeclarationProcessor` |
-| Functions | lowerCamelCase | `processDeclarations()` |
-| Properties | lowerCamelCase | `declarationCount` |
-| Constants | UPPER_SNAKE_CASE | `MAX_COUNT` |
-| Backing properties | underscore prefix | `_elementList` |
-
-### Acronyms
-
-- 2 letters: both uppercase (`IOStream`)
-- 3+ letters: capitalize first only (`XmlFormatter`)
-
-## Formatting
-
-### Indentation
-
-```kotlin
-if (elements != null) {
-    for (element in elements) {
-        // 4 spaces indentation
-    }
-}
-```
-
-### Horizontal Whitespace
-
-```kotlin
-// Binary operators with spaces
-val sum = a + b
-
-// No space around range
-for (i in 0..n) { }
-
-// No space around dot
-foo.bar().filter { it > 2 }
-
-// Space after control keywords
-if (condition) { }
-```
-
-### Colons
-
-```kotlin
-// Type and supertype: space before
-abstract class Foo<out T : Any> : IFoo {
-    // Declaration and type: no space before
-    abstract fun foo(a: Int): T
-}
-```
-
-### Function Signatures
-
-```kotlin
-// Short: single line
-fun foo(a: Int): String = a.toString()
-
-// Long: break parameters
-fun longMethodName(
-    argument: ArgumentType = defaultValue,
-    argument2: AnotherArgumentType,
-): ReturnType {
-    // body
-}
-```
-
-### Trailing Commas
-
-```kotlin
-class Person(
-    val firstName: String,
-    val lastName: String,
-    val age: Int, // trailing comma
-)
-```
-
-## Idiomatic Patterns
-
-### Immutability
-
-```kotlin
-// Prefer val
-val name = "Kotlin"
-
-// Prefer immutable collections
-val items = listOf(1, 2, 3)
-```
-
-### Default Parameters
-
-```kotlin
-// Prefer over overloads
-fun read(
-    b: ByteArray,
-    off: Int = 0,
-    len: Int = b.size,
-) { }
-```
-
-### Expression Bodies
-
-```kotlin
-// Prefer for simple functions
-fun square(x: Int) = x * x
-```
-
-### Conditionals
-
-```kotlin
-// Use if for binary
-return if (x) foo() else bar()
-
-// Use when for multiple
-return when (x) {
-    0 -> "zero"
-    1 -> "one"
-    else -> "many"
-}
-```
-
-### Functional Operations
-
-```kotlin
-// Prefer
-list.filter { it > 10 }
-    .map { it * 2 }
-    .take(5)
-
-// Over manual loops
-```
-
-### Ranges
-
-```kotlin
-// Good: open-ended range
-for (i in 0..<n) { }
-
-// Avoid
-for (i in 0..n - 1) { }
-```
-
-## Null Safety
-
-```kotlin
-// Safe call
-val length = text?.length
-
-// Elvis operator
-val name = user?.name ?: "Unknown"
-
-// Let for non-null
-user?.let {
-    println("Hello, ${it.name}")
-}
-
-// Not-null assertion (use sparingly)
-val name = user!!.name
-```
-
-## Documentation
-
-```kotlin
-/**
- * Returns the absolute value of the given [number].
- */
-fun abs(number: Int): Int = if (number < 0) -number else number
-
-/**
- * A group of *members*.
- *
- * This class has no useful logic; it's just a documentation example.
- *
- * @property name the name of this group.
- * @constructor Creates an empty group.
- */
-class Group(val name: String) {
-    /**
-     * Adds a [member] to this group.
-     * @return the new size of the group.
-     */
-    fun add(member: Member): Int { ... }
-}
-```
-
-## Avoid Redundant Constructs
-
-```kotlin
-// Avoid explicit Unit return
-fun foo() { } // not: fun foo(): Unit { }
-
-// Avoid semicolons
-val x = 1 // not: val x = 1;
-
-// Use simple string templates
-"$name" // not: "${name}"
-```

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

@@ -1,234 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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/index.yaml

@@ -1,27 +0,0 @@
-# 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/AGENT.md

@@ -1,47 +0,0 @@
-# Python Expert Agent
-
-> **Type**: SW Engineer
-> **Source**: Internal
-
-## Purpose
-
-Expert Python developer specialized in writing Pythonic, clean, and maintainable code following PEP 8 and The Zen of Python.
-
-## Capabilities
-
-1. Write idiomatic Python code following PEP 8
-2. Review and refactor Python code for best practices
-3. Design clean APIs and module structures
-4. Implement proper exception handling patterns
-5. Optimize Python applications for performance
-6. Apply The Zen of Python principles
-
-## When to Use
-
-- Writing new Python applications or packages
-- Reviewing existing Python code for improvements
-- Designing Python APIs and libraries
-- Debugging issues in Python code
-- Learning Python best practices
-
-## Skills
-
-| Skill | Purpose |
-|-------|---------|
-| python-best-practices | Core Python development guidelines from PEP 8 |
-
-## Guides
-
-| Guide | Purpose |
-|-------|---------|
-| python | Reference documentation from official Python docs |
-
-## Workflow
-
-```
-1. Understand requirements
-2. Apply python-best-practices skill
-3. Reference python guide for specific patterns
-4. Write/review code with Pythonic style
-5. Ensure PEP 8 compliance and readability
-```