oh-my-customcode 0.1.3 → 0.2.0

package/templates/agents/manager/supplier/refs/guides/go-backend/project-layout.md

@@ -1,243 +0,0 @@
-# Standard Go Project Layout
-
-> Source: https://github.com/golang-standards/project-layout
-
-## Directory Structure
-
-```
-project/
-├── cmd/                    # Main applications
-│   ├── server/
-│   │   └── main.go
-│   └── worker/
-│       └── main.go
-├── internal/               # Private code
-│   ├── handler/
-│   ├── service/
-│   ├── repository/
-│   ├── model/
-│   └── config/
-├── pkg/                    # Public library code
-│   └── validator/
-├── api/                    # API definitions
-│   ├── openapi.yaml
-│   └── proto/
-├── configs/                # Configuration files
-│   └── config.yaml
-├── scripts/                # Build scripts
-│   └── build.sh
-├── test/                   # Additional test data
-│   └── testdata/
-├── docs/                   # Documentation
-├── Dockerfile
-├── Makefile
-├── go.mod
-└── go.sum
-```
-
-## Directory Descriptions
-
-### `/cmd`
-
-Main applications for this project. Each application has its own subdirectory.
-
-```go
-// cmd/server/main.go
-package main
-
-import (
-    "log"
-    "myapp/internal/config"
-    "myapp/internal/handler"
-    "myapp/internal/service"
-)
-
-func main() {
-    cfg, err := config.Load()
-    if err != nil {
-        log.Fatal(err)
-    }
-
-    svc := service.New(cfg)
-    h := handler.New(svc)
-
-    log.Fatal(h.ListenAndServe(cfg.Addr))
-}
-```
-
-### `/internal`
-
-Private application and library code. Not importable by other projects.
-
-```
-internal/
-├── handler/        # HTTP/gRPC handlers
-│   └── user.go
-├── service/        # Business logic
-│   └── user.go
-├── repository/     # Data access
-│   └── user.go
-├── model/          # Domain models
-│   └── user.go
-└── config/         # Configuration
-    └── config.go
-```
-
-### `/pkg`
-
-Library code safe for external use.
-
-```go
-// pkg/validator/validator.go
-package validator
-
-func ValidateEmail(email string) bool {
-    // validation logic
-}
-```
-
-### `/api`
-
-API definitions (OpenAPI/Swagger, Protocol Buffers).
-
-```yaml
-# api/openapi.yaml
-openapi: "3.0.0"
-info:
-  title: "My API"
-  version: "1.0.0"
-paths:
-  /users:
-    get:
-      summary: "List users"
-```
-
-## Common Patterns
-
-### Application Structure
-
-```go
-// internal/app/app.go
-type App struct {
-    config  *config.Config
-    db      *sql.DB
-    cache   *redis.Client
-    handler *handler.Handler
-}
-
-func New(cfg *config.Config) (*App, error) {
-    db, err := sql.Open("postgres", cfg.DatabaseURL)
-    if err != nil {
-        return nil, fmt.Errorf("open db: %w", err)
-    }
-
-    cache := redis.NewClient(&redis.Options{
-        Addr: cfg.RedisURL,
-    })
-
-    repo := repository.New(db)
-    svc := service.New(repo, cache)
-    h := handler.New(svc)
-
-    return &App{
-        config:  cfg,
-        db:      db,
-        cache:   cache,
-        handler: h,
-    }, nil
-}
-
-func (a *App) Run() error {
-    return http.ListenAndServe(a.config.Addr, a.handler.Router())
-}
-
-func (a *App) Shutdown(ctx context.Context) error {
-    if err := a.db.Close(); err != nil {
-        return err
-    }
-    return a.cache.Close()
-}
-```
-
-### Main Entry Point
-
-```go
-// cmd/server/main.go
-package main
-
-import (
-    "context"
-    "log/slog"
-    "os"
-    "os/signal"
-    "syscall"
-
-    "myapp/internal/app"
-    "myapp/internal/config"
-)
-
-func main() {
-    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
-    slog.SetDefault(logger)
-
-    cfg, err := config.Load()
-    if err != nil {
-        slog.Error("load config", "error", err)
-        os.Exit(1)
-    }
-
-    application, err := app.New(cfg)
-    if err != nil {
-        slog.Error("create app", "error", err)
-        os.Exit(1)
-    }
-
-    // Graceful shutdown
-    ctx, stop := signal.NotifyContext(
-        context.Background(),
-        syscall.SIGINT, syscall.SIGTERM,
-    )
-    defer stop()
-
-    go func() {
-        slog.Info("starting server", "addr", cfg.Addr)
-        if err := application.Run(); err != nil {
-            slog.Error("server error", "error", err)
-        }
-    }()
-
-    <-ctx.Done()
-    slog.Info("shutting down")
-
-    shutdownCtx, cancel := context.WithTimeout(
-        context.Background(),
-        30*time.Second,
-    )
-    defer cancel()
-
-    if err := application.Shutdown(shutdownCtx); err != nil {
-        slog.Error("shutdown error", "error", err)
-    }
-}
-```
-
-### Makefile
-
-```makefile
-.PHONY: build run test lint
-
-build:
-	go build -o bin/server ./cmd/server
-
-run:
-	go run ./cmd/server
-
-test:
-	go test -v -race ./...
-
-lint:
-	golangci-lint run
-
-docker:
-	docker build -t myapp .
-```

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

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

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