oh-my-customcode 0.1.4 → 0.2.1

package/templates/agents/sw-engineer/language/golang-expert/refs/golang/effective-go.md

@@ -1,309 +0,0 @@
-# Effective Go Reference
-
-> Source: https://go.dev/doc/effective_go
-
-## Introduction
-
-Go is a new language. Although it borrows ideas from existing languages, it has unusual properties that make effective Go programs different in character from programs written in its relatives. A straightforward translation of a C++ or Java program into Go is unlikely to produce a satisfactory result—Java programs are written in Java, not Go.
-
-## Formatting
-
-Use `gofmt` (or `goimports`) to format all Go code. This eliminates formatting debates and ensures consistency.
-
-Key points:
-- Indentation: tabs, not spaces
-- No line length limit (but break long lines sensibly)
-- Fewer parentheses than C/Java
-
-## Commentary
-
-Go provides C-style `/* */` block comments and C++-style `//` line comments.
-
-- Package comments: precede package clause, block comment for multi-line
-- Doc comments: precede declarations, complete sentences starting with name
-- `godoc` extracts documentation from comments
-
-Example:
-```go
-// Package regexp implements a simple library for regular expressions.
-package regexp
-
-// Compile parses a regular expression and returns, if successful,
-// a Regexp that can be used to match against text.
-func Compile(str string) (*Regexp, error) {
-```
-
-## Names
-
-### Package Names
-
-- Short, concise, lowercase, single-word names
-- No underscores or mixedCaps
-- Name is the base name of its source directory
-- Don't stutter: `bufio.Reader`, not `bufio.BufReader`
-
-### Getters
-
-- Don't use "Get" prefix
-- `owner := obj.Owner()` not `obj.GetOwner()`
-- Setters can use "Set": `obj.SetOwner(user)`
-
-### Interface Names
-
-- One-method interfaces: method name + "-er" suffix
-- `Reader`, `Writer`, `Formatter`, `Notifier`
-
-### MixedCaps
-
-- Use `MixedCaps` or `mixedCaps` rather than underscores
-- Exported: `MixedCaps` (capital first letter)
-- Unexported: `mixedCaps` (lowercase first letter)
-
-## Control Structures
-
-### If
-
-```go
-// With initialization statement
-if err := file.Chmod(0664); err != nil {
-    log.Print(err)
-    return err
-}
-
-// Avoid unnecessary else
-if err != nil {
-    return err
-}
-// continue normal flow
-```
-
-### For
-
-```go
-// Like C's for
-for init; condition; post { }
-
-// Like C's while
-for condition { }
-
-// Like C's for(;;)
-for { }
-
-// Range over slice
-for key, value := range oldMap {
-    newMap[key] = value
-}
-
-// Range over string (runes)
-for pos, char := range "日本語" {
-    fmt.Printf("character %c starts at byte position %d\n", char, pos)
-}
-```
-
-### Switch
-
-```go
-// No automatic fallthrough
-switch c {
-case ' ', '?', '&', '=', '#', '+', '%':
-    return true
-}
-
-// Type switch
-switch t := t.(type) {
-case bool:
-    fmt.Printf("boolean %t\n", t)
-case int:
-    fmt.Printf("integer %d\n", t)
-}
-```
-
-## Functions
-
-### Multiple Return Values
-
-```go
-func (file *File) Write(b []byte) (n int, err error)
-```
-
-### Named Result Parameters
-
-```go
-func ReadFull(r Reader, buf []byte) (n int, err error) {
-    for len(buf) > 0 && err == nil {
-        var nr int
-        nr, err = r.Read(buf)
-        n += nr
-        buf = buf[nr:]
-    }
-    return
-}
-```
-
-### Defer
-
-```go
-func Contents(filename string) (string, error) {
-    f, err := os.Open(filename)
-    if err != nil {
-        return "", err
-    }
-    defer f.Close()  // f.Close will run when we're finished.
-    // ...
-}
-```
-
-## Data
-
-### Allocation with new
-
-`new(T)` allocates zeroed storage for a new item of type `T` and returns its address, a value of type `*T`.
-
-```go
-p := new(SyncedBuffer)  // type *SyncedBuffer
-var v SyncedBuffer      // type SyncedBuffer
-```
-
-### Allocation with make
-
-`make(T, args)` creates slices, maps, and channels only. It returns an initialized (not zeroed) value of type `T` (not `*T`).
-
-```go
-make([]int, 10, 100)      // slice with len=10, cap=100
-make(map[string]int)      // map
-make(chan int, 100)       // buffered channel
-```
-
-### Arrays and Slices
-
-```go
-// Array - fixed size, value type
-var a [10]int
-
-// Slice - dynamic size, reference to array
-s := make([]int, 10)
-s = append(s, 1, 2, 3)
-```
-
-### Maps
-
-```go
-m := make(map[string]int)
-m["key"] = 42
-
-// Comma ok idiom
-if val, ok := m["key"]; ok {
-    // key exists
-}
-
-delete(m, "key")
-```
-
-## Methods
-
-### Pointer vs Value Receivers
-
-```go
-// Value receiver - operates on copy
-func (s MyStruct) ValueMethod() { }
-
-// Pointer receiver - can modify, avoids copy
-func (s *MyStruct) PointerMethod() { }
-```
-
-Rule: If any method needs a pointer receiver, all methods on that type should have pointer receivers.
-
-## Interfaces
-
-```go
-type Reader interface {
-    Read(p []byte) (n int, err error)
-}
-
-type Writer interface {
-    Write(p []byte) (n int, err error)
-}
-
-// Composition
-type ReadWriter interface {
-    Reader
-    Writer
-}
-```
-
-## Embedding
-
-```go
-type ReadWriter struct {
-    *Reader  // embedded
-    *Writer  // embedded
-}
-```
-
-## Concurrency
-
-### Goroutines
-
-```go
-go list.Sort()  // run list.Sort concurrently
-```
-
-### Channels
-
-```go
-ci := make(chan int)            // unbuffered channel of integers
-cj := make(chan int, 0)         // unbuffered channel of integers
-cs := make(chan *os.File, 100)  // buffered channel of pointers to Files
-
-c <- 1    // send
-v := <-c  // receive
-```
-
-### Select
-
-```go
-select {
-case v := <-ch1:
-    fmt.Println("received from ch1:", v)
-case ch2 <- 42:
-    fmt.Println("sent to ch2")
-default:
-    fmt.Println("no communication")
-}
-```
-
-## Errors
-
-```go
-type error interface {
-    Error() string
-}
-
-// Creating errors
-errors.New("message")
-fmt.Errorf("operation failed: %w", err)
-
-// Checking errors
-if err != nil {
-    return err
-}
-```
-
-## Panic and Recover
-
-```go
-func server(workChan <-chan *Work) {
-    for work := range workChan {
-        go safelyDo(work)
-    }
-}
-
-func safelyDo(work *Work) {
-    defer func() {
-        if err := recover(); err != nil {
-            log.Println("work failed:", err)
-        }
-    }()
-    do(work)
-}
-```

package/templates/agents/sw-engineer/language/golang-expert/refs/golang/error-handling.md

@@ -1,250 +0,0 @@
-# Go Error Handling
-
-> Reference for error handling patterns in Go
-
-## Error Interface
-
-```go
-type error interface {
-    Error() string
-}
-```
-
-Errors are values. They can be stored, passed, and compared.
-
-## Creating Errors
-
-### Simple Errors
-
-```go
-import "errors"
-
-err := errors.New("something went wrong")
-```
-
-### Formatted Errors
-
-```go
-import "fmt"
-
-err := fmt.Errorf("failed to process %s: %v", filename, err)
-```
-
-### Custom Error Types
-
-```go
-type MyError struct {
-    Code    int
-    Message string
-}
-
-func (e *MyError) Error() string {
-    return fmt.Sprintf("error %d: %s", e.Code, e.Message)
-}
-```
-
-## Handling Errors
-
-### Basic Pattern
-
-```go
-result, err := doSomething()
-if err != nil {
-    return err
-}
-// use result
-```
-
-### Adding Context
-
-```go
-result, err := doSomething()
-if err != nil {
-    return fmt.Errorf("doSomething failed: %w", err)
-}
-```
-
-### Multiple Returns
-
-```go
-func divide(a, b float64) (float64, error) {
-    if b == 0 {
-        return 0, errors.New("division by zero")
-    }
-    return a / b, nil
-}
-```
-
-## Error Wrapping (Go 1.13+)
-
-### Wrapping Errors
-
-```go
-// Use %w verb to wrap
-if err != nil {
-    return fmt.Errorf("operation failed: %w", err)
-}
-```
-
-### Unwrapping Errors
-
-```go
-// errors.Unwrap returns the wrapped error
-inner := errors.Unwrap(err)
-
-// errors.Is checks if any error in chain matches
-if errors.Is(err, os.ErrNotExist) {
-    // handle file not found
-}
-
-// errors.As finds first error matching type
-var pathErr *os.PathError
-if errors.As(err, &pathErr) {
-    fmt.Println("failed path:", pathErr.Path)
-}
-```
-
-## Sentinel Errors
-
-```go
-var (
-    ErrNotFound     = errors.New("not found")
-    ErrUnauthorized = errors.New("unauthorized")
-    ErrInvalid      = errors.New("invalid input")
-)
-
-func fetch(id string) (*Item, error) {
-    item, ok := store[id]
-    if !ok {
-        return nil, ErrNotFound
-    }
-    return item, nil
-}
-
-// Usage
-item, err := fetch("123")
-if errors.Is(err, ErrNotFound) {
-    // handle not found
-}
-```
-
-## Error Handling Strategies
-
-### Fail Fast
-
-```go
-func process() error {
-    if err := step1(); err != nil {
-        return err
-    }
-    if err := step2(); err != nil {
-        return err
-    }
-    return step3()
-}
-```
-
-### Deferred Cleanup
-
-```go
-func processFile(path string) (err error) {
-    f, err := os.Open(path)
-    if err != nil {
-        return err
-    }
-    defer func() {
-        if cerr := f.Close(); cerr != nil && err == nil {
-            err = cerr
-        }
-    }()
-    // process file
-    return nil
-}
-```
-
-### Error Aggregation
-
-```go
-type MultiError []error
-
-func (m MultiError) Error() string {
-    var msgs []string
-    for _, err := range m {
-        msgs = append(msgs, err.Error())
-    }
-    return strings.Join(msgs, "; ")
-}
-
-func validateAll(items []Item) error {
-    var errs MultiError
-    for _, item := range items {
-        if err := validate(item); err != nil {
-            errs = append(errs, err)
-        }
-    }
-    if len(errs) > 0 {
-        return errs
-    }
-    return nil
-}
-```
-
-## Panic and Recover
-
-### When to Panic
-
-- Unrecoverable errors during initialization
-- Programming errors (nil pointer, out of bounds)
-- Violation of invariants
-
-```go
-func MustCompile(pattern string) *Regexp {
-    re, err := Compile(pattern)
-    if err != nil {
-        panic(err)
-    }
-    return re
-}
-```
-
-### Recovering from Panic
-
-```go
-func safeCall(fn func()) (err error) {
-    defer func() {
-        if r := recover(); r != nil {
-            err = fmt.Errorf("panic recovered: %v", r)
-        }
-    }()
-    fn()
-    return nil
-}
-```
-
-### Package Boundary Rule
-
-- Convert panics to errors at package boundaries
-- Don't let panics escape your API
-
-```go
-func (s *Server) handleRequest(w http.ResponseWriter, r *http.Request) {
-    defer func() {
-        if err := recover(); err != nil {
-            log.Printf("panic: %v\n%s", err, debug.Stack())
-            http.Error(w, "Internal Server Error", 500)
-        }
-    }()
-    // handle request
-}
-```
-
-## Best Practices
-
-1. **Handle errors immediately** after the call
-2. **Add context** when propagating errors
-3. **Use error wrapping** with `%w` for error chains
-4. **Define sentinel errors** for known conditions
-5. **Don't ignore errors** (at minimum, log them)
-6. **Prefer errors over panics** in library code
-7. **Document error returns** in function comments
-8. **Test error paths** as thoroughly as success paths

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

@@ -1,27 +0,0 @@
-# Golang Guide
-
-metadata:
-  name: golang
-  description: Go language reference documentation
-
-source:
-  type: external
-  origin: go.dev
-  url: https://go.dev/doc/effective_go
-  last_fetched: "2026-01-22"
-
-documents:
-  - name: effective-go
-    path: ./effective-go.md
-    description: Effective Go - official best practices guide
-
-  - name: concurrency
-    path: ./concurrency.md
-    description: Concurrency patterns and practices
-
-  - name: error-handling
-    path: ./error-handling.md
-    description: Error handling patterns
-
-used_by:
-  - golang-expert

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

@@ -1,122 +0,0 @@
-# Java 21 Expert Agent
-
-> **Type**: SW Engineer
-> **Source**: Internal
-
-## Purpose
-
-Expert Java 21 developer specialized in modern Java features including Virtual Threads, Pattern Matching, Record Patterns, and Sequenced Collections.
-
-## Capabilities
-
-1. Write modern Java 21 code leveraging latest language features
-2. Implement Virtual Threads (JEP 444) for scalable concurrent applications
-3. Apply Pattern Matching for switch expressions and instanceof
-4. Use Record Patterns (JEP 440) for data decomposition
-5. Leverage Sequenced Collections (JEP 431) for ordered data structures
-6. Follow Google Java Style Guide and best practices
-7. Migrate legacy Java code to modern Java 21 idioms
-
-## When to Use
-
-- Writing new Java 21 applications or libraries
-- Reviewing existing Java code for modernization opportunities
-- Implementing high-concurrency systems with Virtual Threads
-- Designing data-centric APIs with Records and Sealed Classes
-- Migrating from older Java versions to Java 21
-
-## Key Java 21 Features
-
-| Feature | JEP | Description |
-|---------|-----|-------------|
-| Virtual Threads | JEP 444 | Lightweight threads for scalable concurrency |
-| Pattern Matching for switch | - | Exhaustive switch with type patterns |
-| Record Patterns | JEP 440 | Deconstruct record values in patterns |
-| Sequenced Collections | JEP 431 | Collections with defined encounter order |
-
-## Reference Documentation
-
-| Resource | URL |
-|----------|-----|
-| JDK 21 Documentation | https://docs.oracle.com/en/java/javase/21/ |
-| JDK 21 Guides | https://docs.oracle.com/en/java/javase/21/books.html |
-| JEPs since JDK 17 | https://openjdk.org/projects/jdk/21/jeps-since-jdk-17 |
-| Google Java Style Guide | https://google.github.io/styleguide/javaguide.html |
-
-## Skills
-
-| Skill | Purpose |
-|-------|---------|
-| java21-best-practices | Core Java 21 development guidelines |
-
-## Guides
-
-| Guide | Purpose |
-|-------|---------|
-| java21 | Reference documentation from official JDK 21 docs |
-
-## Workflow
-
-```
-1. Understand requirements
-2. Apply java21-best-practices skill
-3. Reference java21 guide for specific patterns
-4. Write/review code with modern Java 21 features
-5. Ensure proper use of Virtual Threads, Pattern Matching, Records
-6. Follow Google Java Style Guide for formatting
-```
-
-## Code Examples
-
-### Virtual Threads (JEP 444)
-
-```java
-// Create virtual threads for high-concurrency tasks
-try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
-    IntStream.range(0, 10_000).forEach(i -> {
-        executor.submit(() -> {
-            Thread.sleep(Duration.ofSeconds(1));
-            return i;
-        });
-    });
-}
-```
-
-### Record Patterns (JEP 440)
-
-```java
-record Point(int x, int y) {}
-record Rectangle(Point topLeft, Point bottomRight) {}
-
-static void printRectangle(Rectangle r) {
-    if (r instanceof Rectangle(Point(var x1, var y1), Point(var x2, var y2))) {
-        System.out.printf("Rectangle from (%d,%d) to (%d,%d)%n", x1, y1, x2, y2);
-    }
-}
-```
-
-### Pattern Matching for switch
-
-```java
-static String format(Object obj) {
-    return switch (obj) {
-        case Integer i -> String.format("int %d", i);
-        case Long l    -> String.format("long %d", l);
-        case Double d  -> String.format("double %f", d);
-        case String s  -> String.format("String %s", s);
-        case null      -> "null";
-        default        -> obj.toString();
-    };
-}
-```
-
-### Sequenced Collections (JEP 431)
-
-```java
-SequencedCollection<String> list = new ArrayList<>();
-list.addFirst("first");
-list.addLast("last");
-String first = list.getFirst();
-String last = list.getLast();
-SequencedCollection<String> reversed = list.reversed();
-```