oh-my-customcode 0.7.0 → 0.9.0

package/templates/.codex/skills/go-backend-best-practices/SKILL.md

@@ -0,0 +1,338 @@
+---
+name: go-backend-best-practices
+description: Go backend patterns from Uber style and standard layout
+user-invocable: false
+---
+
+## Purpose
+
+Apply Go backend patterns for building production-ready services.
+
+## Rules
+
+### 1. Project Structure (Standard Layout)
+
+```yaml
+layout: |
+  project/
+  ├── cmd/
+  │   └── server/
+  │       └── main.go
+  ├── internal/
+  │   ├── handler/
+  │   ├── service/
+  │   ├── repository/
+  │   └── model/
+  ├── pkg/
+  │   └── shared/
+  ├── api/
+  │   └── openapi.yaml
+  ├── configs/
+  ├── scripts/
+  ├── Dockerfile
+  ├── Makefile
+  └── go.mod
+
+directories:
+  cmd: Main applications (one per binary)
+  internal: Private application code
+  pkg: Library code safe for external use
+  api: API definitions (OpenAPI, protobuf)
+  configs: Configuration files
+  scripts: Build and CI scripts
+```
+
+### 2. Error Handling (Uber Style)
+
+```yaml
+principles:
+  - Wrap errors with context using %w
+  - Handle errors once (don't log AND return)
+  - Use sentinel errors for specific conditions
+  - Name error variables with Err prefix
+
+patterns: |
+  // Sentinel errors
+  var (
+      ErrNotFound = errors.New("not found")
+      ErrInvalidInput = errors.New("invalid input")
+  )
+
+  // Wrap with context
+  func getUser(id string) (*User, error) {
+      user, err := db.FindUser(id)
+      if err != nil {
+          return nil, fmt.Errorf("getUser %s: %w", id, err)
+      }
+      return user, nil
+  }
+
+  // Check specific errors
+  if errors.Is(err, ErrNotFound) {
+      return http.StatusNotFound
+  }
+```
+
+### 3. Concurrency (Uber Style)
+
+```yaml
+channels:
+  size: "Use 0 (unbuffered) or 1 only"
+  larger: "Requires careful review"
+
+goroutines:
+  never: fire-and-forget
+  always: wait for completion or manage lifecycle
+
+patterns: |
+  // Wait group for goroutines
+  func process(items []Item) error {
+      var wg sync.WaitGroup
+      errCh := make(chan error, 1)
+
+      for _, item := range items {
+          wg.Add(1)
+          go func(item Item) {
+              defer wg.Done()
+              if err := processItem(item); err != nil {
+                  select {
+                  case errCh <- err:
+                  default:
+                  }
+              }
+          }(item)
+      }
+
+      wg.Wait()
+      close(errCh)
+      return <-errCh
+  }
+
+  // Context for cancellation
+  func longRunningTask(ctx context.Context) error {
+      for {
+          select {
+          case <-ctx.Done():
+              return ctx.Err()
+          default:
+              // do work
+          }
+      }
+  }
+```
+
+### 4. HTTP Server
+
+```yaml
+structure:
+  handler: HTTP layer (request/response)
+  service: Business logic
+  repository: Data access
+
+patterns: |
+  // Handler with dependency injection
+  type UserHandler struct {
+      service UserService
+  }
+
+  func NewUserHandler(s UserService) *UserHandler {
+      return &UserHandler{service: s}
+  }
+
+  func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
+      id := chi.URLParam(r, "id")
+
+      user, err := h.service.GetUser(r.Context(), id)
+      if err != nil {
+          if errors.Is(err, ErrNotFound) {
+              http.Error(w, "user not found", http.StatusNotFound)
+              return
+          }
+          http.Error(w, "internal error", http.StatusInternalServerError)
+          return
+      }
+
+      json.NewEncoder(w).Encode(user)
+  }
+
+  // Router setup
+  func NewRouter(h *UserHandler) *chi.Mux {
+      r := chi.NewRouter()
+      r.Use(middleware.Logger)
+      r.Use(middleware.Recoverer)
+
+      r.Route("/api/v1", func(r chi.Router) {
+          r.Get("/users/{id}", h.GetUser)
+          r.Post("/users", h.CreateUser)
+      })
+
+      return r
+  }
+```
+
+### 5. Dependency Injection
+
+```yaml
+approach: constructor injection
+avoid: global variables
+
+patterns: |
+  // Service with dependencies
+  type UserService struct {
+      repo   UserRepository
+      cache  Cache
+      logger *slog.Logger
+  }
+
+  func NewUserService(
+      repo UserRepository,
+      cache Cache,
+      logger *slog.Logger,
+  ) *UserService {
+      return &UserService{
+          repo:   repo,
+          cache:  cache,
+          logger: logger,
+      }
+  }
+
+  // Wire up in main
+  func main() {
+      logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
+      db := database.New(cfg.DatabaseURL)
+      cache := redis.New(cfg.RedisURL)
+
+      repo := repository.NewUserRepository(db)
+      service := service.NewUserService(repo, cache, logger)
+      handler := handler.NewUserHandler(service)
+
+      router := handler.NewRouter(handler)
+      http.ListenAndServe(":8080", router)
+  }
+```
+
+### 6. Configuration
+
+```yaml
+approach:
+  - Use environment variables
+  - Validate at startup
+  - Group related settings
+
+patterns: |
+  type Config struct {
+      Server   ServerConfig
+      Database DatabaseConfig
+      Redis    RedisConfig
+  }
+
+  type ServerConfig struct {
+      Host         string        `env:"SERVER_HOST" envDefault:"0.0.0.0"`
+      Port         int           `env:"SERVER_PORT" envDefault:"8080"`
+      ReadTimeout  time.Duration `env:"SERVER_READ_TIMEOUT" envDefault:"5s"`
+      WriteTimeout time.Duration `env:"SERVER_WRITE_TIMEOUT" envDefault:"10s"`
+  }
+
+  func LoadConfig() (*Config, error) {
+      var cfg Config
+      if err := env.Parse(&cfg); err != nil {
+          return nil, fmt.Errorf("parse config: %w", err)
+      }
+      return &cfg, nil
+  }
+```
+
+### 7. Testing
+
+```yaml
+patterns:
+  table_driven: for comprehensive coverage
+  interfaces: for mocking
+  parallel: for speed
+
+example: |
+  func TestUserService_GetUser(t *testing.T) {
+      tests := []struct {
+          name    string
+          userID  string
+          mock    func(*MockRepository)
+          want    *User
+          wantErr error
+      }{
+          {
+              name:   "success",
+              userID: "123",
+              mock: func(m *MockRepository) {
+                  m.EXPECT().FindByID("123").Return(&User{ID: "123"}, nil)
+              },
+              want: &User{ID: "123"},
+          },
+          {
+              name:   "not found",
+              userID: "999",
+              mock: func(m *MockRepository) {
+                  m.EXPECT().FindByID("999").Return(nil, ErrNotFound)
+              },
+              wantErr: ErrNotFound,
+          },
+      }
+
+      for _, tt := range tests {
+          t.Run(tt.name, func(t *testing.T) {
+              t.Parallel()
+              ctrl := gomock.NewController(t)
+              repo := NewMockRepository(ctrl)
+              tt.mock(repo)
+
+              svc := NewUserService(repo, nil, slog.Default())
+              got, err := svc.GetUser(context.Background(), tt.userID)
+
+              if !errors.Is(err, tt.wantErr) {
+                  t.Errorf("got error %v, want %v", err, tt.wantErr)
+              }
+              if diff := cmp.Diff(tt.want, got); diff != "" {
+                  t.Errorf("mismatch (-want +got):\n%s", diff)
+              }
+          })
+      }
+  }
+```
+
+### 8. Performance (Uber Style)
+
+```yaml
+guidelines:
+  - Use strconv over fmt for conversions
+  - Pre-allocate slices with known capacity
+  - Avoid repeated string-to-byte conversions
+  - Copy slices/maps at boundaries
+
+patterns: |
+  // Pre-allocate
+  items := make([]Item, 0, len(input))
+
+  // strconv for conversions
+  s := strconv.Itoa(n) // not fmt.Sprintf("%d", n)
+
+  // Copy at boundaries
+  func (s *Store) GetItems() []Item {
+      s.mu.RLock()
+      defer s.mu.RUnlock()
+      items := make([]Item, len(s.items))
+      copy(items, s.items)
+      return items
+  }
+```
+
+## Application
+
+When writing Go backend code:
+
+1. **Always** use standard project layout
+2. **Always** wrap errors with context
+3. **Never** fire-and-forget goroutines
+4. **Use** constructor injection
+5. **Use** table-driven tests
+6. **Handle** errors once
+7. **Copy** data at boundaries
+8. **Validate** config at startup

package/templates/.codex/skills/go-best-practices/CLAUDE.md

@@ -0,0 +1,9 @@
+<claude-mem-context>
+# Recent Activity
+
+### Feb 5, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #8 | 8:07 PM | 🔵 | Skill Definition Structure | ~626 |
+</claude-mem-context>

package/templates/.codex/skills/go-best-practices/SKILL.md

@@ -0,0 +1,203 @@
+---
+name: go-best-practices
+description: Idiomatic Go patterns from Effective Go
+user-invocable: false
+---
+
+## 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/.codex/skills/help/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: help
+description: Show help information for commands and system
+argument-hint: "[command] [--agents] [--rules]"
+---
+
+# Help Skill
+
+Show help information for commands, agents, and system rules.
+
+## Options
+
+```
+--agents, -a     List all available agents
+--commands, -c   List all commands (same as 'lists')
+--rules, -r      List all rules
+```
+
+## Output Format
+
+### Default Help
+```
+AI Agent System - Help
+
+Usage: {command} [arguments] [options]
+
+Quick Start:
+  lists              Show all available commands
+  status             Show system status
+  help <command>     Get help for a specific command
+
+Common Commands:
+  /update-docs       Sync documentation with project
+  /update-external   Update external agents
+  /audit-agents      Check agent dependencies
+  /create-agent      Create a new agent
+
+Use "lists" to see all available commands.
+Use "help <command>" for detailed help.
+```
+
+### Command Help
+```
+help /update-docs
+
+Command: /update-docs
+
+Description:
+  Sync documentation with project structure. Ensures all
+  documentation accurately reflects the current project state.
+
+Usage:
+  /update-docs
+  /update-docs --check
+  /update-docs --target <path>
+
+Options:
+  --check, -c      Check only, don't modify
+  --verbose, -v    Show detailed changes
+  --target, -t     Specific target to update
+
+Examples:
+  /update-docs                 # Update all documentation
+  /update-docs --check         # Check for issues
+  /update-docs --target agents # Update agents only
+```
+
+### Agent List
+```
+help --agents
+
+Available Agents:
+
+Orchestrator:
+  secretary        Manages manager agents
+
+Manager:
+  mgr-creator          Creates new agents
+  mgr-updater          Updates external sources and docs
+  mgr-supplier         Validates dependencies
+
+SW Engineer:
+  lang-golang-expert       Go development (Effective Go)
+  lang-python-expert       Python development (PEP 8)
+  lang-rust-expert         Rust development (API Guidelines)
+  lang-kotlin-expert       Kotlin development (JetBrains)
+  lang-typescript-expert   TypeScript development (Google)
+  fe-vercel-agent  React/Next.js (Vercel)
+
+Backend Engineer:
+  be-fastapi-expert      FastAPI (Python async)
+  be-springboot-expert   Spring Boot (Java)
+  be-go-backend-expert   Go backend (Uber style)
+
+Infra Engineer:
+  infra-docker-expert       Docker containerization
+  infra-aws-expert          AWS architecture
+
+Total: 15 agents
+```
+
+### Rules List
+```
+help --rules
+
+Global Rules:
+
+MUST (Never violate):
+  R000  Language Policy      Korean I/O, English files
+  R001  Safety Rules         Prohibited actions
+  R002  Permission Rules     Tool tiers, file access
+  R006  Agent Design         Structure, separation
+
+SHOULD (Strongly recommended):
+  R003  Interaction Rules    Response format
+  R004  Error Handling       Error levels, recovery
+  R007  Agent Identification Display agent in responses
+  R008  Tool Identification  Display agent when using tools
+
+MAY (Optional):
+  R005  Optimization         Efficiency guidelines
+  R009  Parallel Execution   Max 4 parallel instances
+
+Total: 10 rules
+```