oh-my-customcode 0.1.1 → 0.1.3

package/templates/agents/manager/supplier/refs/guides/go-backend/uber-style.md

@@ -0,0 +1,212 @@
+# Uber Go Style Guide
+
+> Source: https://github.com/uber-go/guide/blob/master/style.md
+
+## Guidelines
+
+### Verify Interface Compliance
+
+```go
+// Compile-time check
+var _ http.Handler = (*Handler)(nil)
+var _ io.Reader = (*MyReader)(nil)
+```
+
+### Receiver Type
+
+```go
+// Value receiver: doesn't modify state
+func (s Stack) Length() int {
+    return len(s.items)
+}
+
+// Pointer receiver: modifies state or is large
+func (s *Stack) Push(item int) {
+    s.items = append(s.items, item)
+}
+```
+
+### Zero-value Mutexes
+
+```go
+// Good: zero-value is valid
+var mu sync.Mutex
+
+// Good: embedded in struct
+type Store struct {
+    mu    sync.Mutex
+    items map[string]Item
+}
+```
+
+### Copy Slices and Maps
+
+```go
+// Returning: copy to prevent external modification
+func (s *Store) GetItems() []Item {
+    s.mu.RLock()
+    defer s.mu.RUnlock()
+    items := make([]Item, len(s.items))
+    copy(items, s.items)
+    return items
+}
+
+// Receiving: copy to prevent caller modification
+func (s *Store) SetItems(items []Item) {
+    s.mu.Lock()
+    defer s.mu.Unlock()
+    s.items = make([]Item, len(items))
+    copy(s.items, items)
+}
+```
+
+### Defer for Cleanup
+
+```go
+func readFile(path string) ([]byte, error) {
+    f, err := os.Open(path)
+    if err != nil {
+        return nil, err
+    }
+    defer f.Close()
+    return io.ReadAll(f)
+}
+
+func process() {
+    mu.Lock()
+    defer mu.Unlock()
+    // ...
+}
+```
+
+### Channel Size
+
+```go
+// Good: unbuffered or 1
+ch := make(chan int)
+ch := make(chan int, 1)
+
+// Requires justification
+ch := make(chan int, 100) // Why 100?
+```
+
+### Start Enums at One
+
+```go
+type Operation int
+
+const (
+    Add Operation = iota + 1
+    Subtract
+    Multiply
+)
+```
+
+### Error Types
+
+```go
+// Sentinel errors
+var ErrNotFound = errors.New("not found")
+
+// Error wrapping
+if err != nil {
+    return fmt.Errorf("failed to get user: %w", err)
+}
+
+// Checking errors
+if errors.Is(err, ErrNotFound) {
+    // handle not found
+}
+```
+
+### Handle Errors Once
+
+```go
+// Bad: logs AND returns
+if err != nil {
+    log.Printf("error: %v", err)
+    return err
+}
+
+// Good: return with context
+if err != nil {
+    return fmt.Errorf("process: %w", err)
+}
+```
+
+### Use strconv Over fmt
+
+```go
+// Good
+s := strconv.Itoa(n)
+n, err := strconv.Atoi(s)
+
+// Slower
+s := fmt.Sprintf("%d", n)
+```
+
+### Table-Driven Tests
+
+```go
+func TestSplit(t *testing.T) {
+    tests := []struct {
+        name  string
+        input string
+        sep   string
+        want  []string
+    }{
+        {
+            name:  "simple",
+            input: "a/b/c",
+            sep:   "/",
+            want:  []string{"a", "b", "c"},
+        },
+        {
+            name:  "empty",
+            input: "",
+            sep:   "/",
+            want:  []string{""},
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            got := strings.Split(tt.input, tt.sep)
+            if diff := cmp.Diff(tt.want, got); diff != "" {
+                t.Errorf("mismatch (-want +got):\n%s", diff)
+            }
+        })
+    }
+}
+```
+
+### Functional Options
+
+```go
+type Server struct {
+    addr    string
+    timeout time.Duration
+}
+
+type Option func(*Server)
+
+func WithTimeout(d time.Duration) Option {
+    return func(s *Server) {
+        s.timeout = d
+    }
+}
+
+func NewServer(addr string, opts ...Option) *Server {
+    s := &Server{
+        addr:    addr,
+        timeout: time.Second * 30,
+    }
+    for _, opt := range opts {
+        opt(s)
+    }
+    return s
+}
+
+// Usage
+server := NewServer(":8080", WithTimeout(time.Minute))
+```

package/templates/agents/manager/supplier/refs/guides/golang/concurrency.md

@@ -0,0 +1,282 @@
+# Go Concurrency Patterns
+
+> Reference for concurrent programming in Go
+
+## Core Philosophy
+
+> Do not communicate by sharing memory; instead, share memory by communicating.
+
+Go's approach to concurrency differs from traditional threading models. Channels provide a way to safely communicate between goroutines without explicit locks.
+
+## Goroutines
+
+A goroutine is a lightweight thread managed by the Go runtime.
+
+```go
+// Start a goroutine
+go doSomething()
+
+// With anonymous function
+go func() {
+    // concurrent work
+}()
+```
+
+### Goroutine Lifecycle
+
+- Created with `go` keyword
+- Runs concurrently with calling goroutine
+- Exits when function returns
+- Main goroutine exit = program exit
+
+## Channels
+
+### Basic Operations
+
+```go
+// Create
+ch := make(chan int)        // unbuffered
+ch := make(chan int, 10)    // buffered, capacity 10
+
+// Send
+ch <- value
+
+// Receive
+value := <-ch
+value, ok := <-ch  // ok is false if channel closed
+
+// Close
+close(ch)
+```
+
+### Unbuffered vs Buffered
+
+| Type | Behavior |
+|------|----------|
+| Unbuffered | Sender blocks until receiver ready |
+| Buffered | Sender blocks only when buffer full |
+
+### Directional Channels
+
+```go
+func sender(ch chan<- int) {
+    ch <- 42  // send-only
+}
+
+func receiver(ch <-chan int) {
+    v := <-ch  // receive-only
+}
+```
+
+## Common Patterns
+
+### Worker Pool
+
+```go
+func worker(id int, jobs <-chan int, results chan<- int) {
+    for j := range jobs {
+        results <- j * 2
+    }
+}
+
+func main() {
+    jobs := make(chan int, 100)
+    results := make(chan int, 100)
+
+    // Start 3 workers
+    for w := 1; w <= 3; w++ {
+        go worker(w, jobs, results)
+    }
+
+    // Send jobs
+    for j := 1; j <= 9; j++ {
+        jobs <- j
+    }
+    close(jobs)
+
+    // Collect results
+    for a := 1; a <= 9; a++ {
+        <-results
+    }
+}
+```
+
+### Fan-Out, Fan-In
+
+```go
+// Fan-out: multiple goroutines read from same channel
+// Fan-in: single goroutine reads from multiple channels
+
+func fanIn(ch1, ch2 <-chan int) <-chan int {
+    out := make(chan int)
+    go func() {
+        for {
+            select {
+            case v := <-ch1:
+                out <- v
+            case v := <-ch2:
+                out <- v
+            }
+        }
+    }()
+    return out
+}
+```
+
+### Pipeline
+
+```go
+func gen(nums ...int) <-chan int {
+    out := make(chan int)
+    go func() {
+        for _, n := range nums {
+            out <- n
+        }
+        close(out)
+    }()
+    return out
+}
+
+func sq(in <-chan int) <-chan int {
+    out := make(chan int)
+    go func() {
+        for n := range in {
+            out <- n * n
+        }
+        close(out)
+    }()
+    return out
+}
+
+// Usage: for v := range sq(sq(gen(2, 3))) { ... }
+```
+
+### Context for Cancellation
+
+```go
+func operation(ctx context.Context) error {
+    select {
+    case <-time.After(time.Second):
+        return nil  // completed
+    case <-ctx.Done():
+        return ctx.Err()  // cancelled
+    }
+}
+
+func main() {
+    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
+    defer cancel()
+
+    if err := operation(ctx); err != nil {
+        log.Fatal(err)
+    }
+}
+```
+
+## Select Statement
+
+```go
+select {
+case v := <-ch1:
+    // received from ch1
+case ch2 <- x:
+    // sent to ch2
+case <-time.After(time.Second):
+    // timeout
+default:
+    // non-blocking
+}
+```
+
+## Synchronization
+
+### sync.WaitGroup
+
+```go
+var wg sync.WaitGroup
+
+for i := 0; i < 5; i++ {
+    wg.Add(1)
+    go func(id int) {
+        defer wg.Done()
+        // work
+    }(i)
+}
+
+wg.Wait()  // blocks until all done
+```
+
+### sync.Mutex
+
+```go
+var (
+    mu      sync.Mutex
+    counter int
+)
+
+func increment() {
+    mu.Lock()
+    defer mu.Unlock()
+    counter++
+}
+```
+
+### sync.Once
+
+```go
+var once sync.Once
+
+func initialize() {
+    once.Do(func() {
+        // runs exactly once
+    })
+}
+```
+
+## Avoiding Common Pitfalls
+
+### Goroutine Leaks
+
+```go
+// BAD: goroutine never exits
+go func() {
+    for {
+        // infinite loop with no exit
+    }
+}()
+
+// GOOD: use context or done channel
+go func(ctx context.Context) {
+    for {
+        select {
+        case <-ctx.Done():
+            return
+        default:
+            // work
+        }
+    }
+}(ctx)
+```
+
+### Race Conditions
+
+```go
+// BAD: race condition
+go func() { x++ }()
+go func() { x++ }()
+
+// GOOD: use channels or mutex
+go func() { ch <- 1 }()
+go func() { ch <- 1 }()
+x += <-ch + <-ch
+```
+
+### Closing Channels
+
+```go
+// Only sender should close
+// Closing already-closed channel panics
+// Sending to closed channel panics
+
+// Pattern: use sync.Once or single sender
+```