oh-my-customcode 0.1.3 → 0.2.0

package/templates/agents/manager/supplier/refs/skills/backend/springboot-best-practices/index.yaml

@@ -1,27 +0,0 @@
-# Spring Boot Best Practices Skill
-
-metadata:
-  name: springboot-best-practices
-  category: backend
-  description: Spring Boot patterns for enterprise Java applications
-
-source:
-  type: internal
-  reference:
-    - https://docs.spring.io/spring-boot/docs/current/reference/html/
-    - https://spring.io/guides
-    - https://www.baeldung.com/spring-boot
-
-provides:
-  - Project structure patterns
-  - Dependency injection best practices
-  - REST API design guidelines
-  - Service layer patterns
-  - Data access patterns
-  - Exception handling
-  - Configuration management
-  - Security implementation
-  - Testing strategies
-
-used_by:
-  - springboot-expert

package/templates/agents/manager/supplier/refs/skills/development/go-best-practices/SKILL.md

@@ -1,202 +0,0 @@
-# Go Best Practices Skill
-
-> **Category**: Development
-> **Source**: Internal (based on Effective Go)
-
-## Purpose
-
-Apply idiomatic Go patterns and best practices from official Go documentation.
-
-## Rules
-
-### 1. Formatting
-
-```yaml
-rules:
-  - Use gofmt for all code formatting
-  - Indentation uses tabs, not spaces
-  - No line length limit, but break long lines sensibly
-  - Let gofmt handle alignment
-```
-
-### 2. Naming Conventions
-
-```yaml
-package_names:
-  - Short, concise, lowercase, single-word
-  - No underscores or mixedCaps
-  - Name is basename of source directory
-  - Example: bufio, not bufIO or buf_io
-
-getters:
-  - No "Get" prefix for getters
-  - obj.Owner() not obj.GetOwner()
-  - Setter can use "Set": obj.SetOwner(user)
-
-interface_names:
-  - One-method interfaces: method name + "er"
-  - Reader, Writer, Formatter, CloseNotifier
-  - Avoid stealing standard names unless same signature
-
-mixedCaps:
-  - Use MixedCaps or mixedCaps, never underscores
-  - Exported: MixedCaps (uppercase first)
-  - Unexported: mixedCaps (lowercase first)
-```
-
-### 3. Control Structures
-
-```yaml
-if_statements:
-  - Accept initialization statement
-  - Prefer: if err := file.Chmod(0664); err != nil
-  - Omit else when if ends with break/continue/return
-  - Avoid unnecessary else
-
-for_loops:
-  - Go's only loop construct
-  - for init; condition; post { } - like C for
-  - for condition { } - like C while
-  - for { } - infinite loop
-  - Use range for strings, slices, arrays, maps, channels
-
-switch:
-  - Cases don't fall through by default
-  - Use fallthrough keyword if needed
-  - Multiple cases: case '0', '1', '2'
-  - Type switch: switch v := x.(type)
-```
-
-### 4. Functions
-
-```yaml
-multiple_returns:
-  - Return multiple values for result + error
-  - func (file *File) Write(b []byte) (n int, err error)
-
-named_results:
-  - Document return values with names
-  - Can simplify code but use judiciously
-  - Unnamed returns OK for short functions
-
-defer:
-  - Executes when function returns
-  - LIFO order for multiple defers
-  - Use for cleanup: unlock mutexes, close files
-  - Arguments evaluated when defer executes, not when called
-```
-
-### 5. Data
-
-```yaml
-new_vs_make:
-  - new(T): allocates zeroed storage, returns *T
-  - make(T, args): creates slices, maps, channels only
-  - make returns initialized (not zeroed) value of type T
-
-slices:
-  - Backed by arrays, can grow
-  - append() to add elements
-  - copy() for safe duplication
-  - Slice of slice shares underlying array
-
-maps:
-  - Reference type, nil until initialized
-  - make(map[KeyType]ValueType)
-  - Comma ok idiom: val, ok := map[key]
-  - delete(map, key) to remove
-```
-
-### 6. Methods
-
-```yaml
-pointer_vs_value_receivers:
-  - Pointer receiver: can modify, no copy overhead
-  - Value receiver: safe from modification
-  - If any method needs pointer, all should use pointer
-  - Rule: values immutable, pointers mutable
-```
-
-### 7. Interfaces
-
-```yaml
-design:
-  - Interfaces define behavior, not data
-  - Small interfaces (1-3 methods) preferred
-  - Accept interfaces, return structs
-  - If type implements interface, it satisfies implicitly
-
-common_interfaces:
-  - io.Reader: Read(p []byte) (n int, err error)
-  - io.Writer: Write(p []byte) (n int, err error)
-  - fmt.Stringer: String() string
-  - error: Error() string
-```
-
-### 8. Concurrency
-
-```yaml
-goroutines:
-  - Lightweight, multiplexed onto OS threads
-  - go function() to start
-  - Don't communicate by sharing memory
-  - Share memory by communicating
-
-channels:
-  - Primary synchronization mechanism
-  - ch := make(chan int) - unbuffered
-  - ch := make(chan int, 100) - buffered
-  - Send: ch <- v
-  - Receive: v := <-ch
-  - Close: close(ch)
-
-patterns:
-  - Don't leak goroutines - ensure they exit
-  - Use context for cancellation
-  - select for multiple channel operations
-  - sync.WaitGroup for goroutine coordination
-```
-
-### 9. Error Handling
-
-```yaml
-principles:
-  - Errors are values, handle them explicitly
-  - Check errors immediately after call
-  - Return errors, don't panic
-  - Add context when propagating: fmt.Errorf("op failed: %w", err)
-
-panic_recover:
-  - Panic for unrecoverable errors only
-  - Library functions should return errors, not panic
-  - Recover only in deferred functions
-  - Convert internal panics to errors at package boundary
-```
-
-### 10. Project Structure
-
-```yaml
-packages:
-  - One package per directory
-  - Package name matches directory name
-  - main package for executables
-  - Avoid circular imports
-
-files:
-  - doc.go for package documentation
-  - _test.go suffix for test files
-  - Group related types and functions
-```
-
-## Application
-
-When writing or reviewing Go code:
-
-1. **Always** run `gofmt` or `goimports`
-2. **Always** handle returned errors
-3. **Prefer** composition over inheritance
-4. **Prefer** small interfaces
-5. **Prefer** channels for goroutine communication
-6. **Avoid** global state
-7. **Avoid** init() when possible
-8. **Document** exported identifiers

package/templates/agents/manager/supplier/refs/skills/development/go-best-practices/index.yaml

@@ -1,25 +0,0 @@
-# Go Best Practices Skill
-
-metadata:
-  name: go-best-practices
-  category: development
-  description: Idiomatic Go patterns from Effective Go
-
-source:
-  type: internal
-  reference: https://go.dev/doc/effective_go
-
-provides:
-  - Go code formatting standards
-  - Naming conventions
-  - Control structure patterns
-  - Function design patterns
-  - Data structure usage
-  - Method receiver guidelines
-  - Interface design
-  - Concurrency patterns
-  - Error handling patterns
-  - Project structure guidelines
-
-used_by:
-  - golang-expert

package/templates/agents/manager/supplier/refs/skills/development/kotlin-best-practices/SKILL.md

@@ -1,255 +0,0 @@
-# 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/manager/supplier/refs/skills/development/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