oh-my-customcode 0.1.2 → 0.1.3

package/templates/agents/infra-engineer/docker-expert/refs/docker/dockerfile-best-practices.md

@@ -0,0 +1,262 @@
+# Dockerfile Best Practices
+
+> Source: https://docs.docker.com/develop/develop-images/dockerfile_best-practices/
+
+## General Guidelines
+
+### Create Ephemeral Containers
+
+Containers should be ephemeral - can be stopped, destroyed, and rebuilt with minimal setup.
+
+### Understand Build Context
+
+```bash
+# Entire directory sent to daemon
+docker build .
+
+# Use .dockerignore to exclude files
+# .dockerignore
+.git
+node_modules
+*.md
+```
+
+### Use Multi-Stage Builds
+
+```dockerfile
+# Build stage
+FROM golang:1.21 AS builder
+WORKDIR /app
+COPY . .
+RUN go build -o myapp
+
+# Runtime stage
+FROM alpine:3.19
+COPY --from=builder /app/myapp /usr/local/bin/
+CMD ["myapp"]
+```
+
+## Dockerfile Instructions
+
+### FROM
+
+```dockerfile
+# Pin versions
+FROM ubuntu:22.04
+
+# Use digest for reproducibility
+FROM node:20@sha256:abc123...
+
+# Use official images
+FROM python:3.12-slim
+```
+
+### RUN
+
+```dockerfile
+# Combine commands
+RUN apt-get update && apt-get install -y \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Use BuildKit cache
+RUN --mount=type=cache,target=/root/.cache/pip \
+    pip install -r requirements.txt
+```
+
+### CMD vs ENTRYPOINT
+
+```dockerfile
+# CMD: Default command (can be overridden)
+CMD ["python", "app.py"]
+
+# ENTRYPOINT: Fixed command
+ENTRYPOINT ["python"]
+CMD ["app.py"]
+
+# Combined
+ENTRYPOINT ["/docker-entrypoint.sh"]
+CMD ["postgres"]
+```
+
+### COPY vs ADD
+
+```dockerfile
+# Prefer COPY (more explicit)
+COPY requirements.txt .
+
+# ADD only for tar extraction or URLs
+ADD archive.tar.gz /app/
+```
+
+### EXPOSE
+
+```dockerfile
+# Documentation only
+EXPOSE 8080
+EXPOSE 443/tcp
+```
+
+### ENV
+
+```dockerfile
+ENV APP_HOME=/app \
+    PATH=$APP_HOME/bin:$PATH
+
+WORKDIR $APP_HOME
+```
+
+### VOLUME
+
+```dockerfile
+# Named mount point
+VOLUME /data
+```
+
+### USER
+
+```dockerfile
+# Create non-root user
+RUN groupadd -r app && useradd -r -g app app
+USER app
+
+# Or use existing
+USER nobody
+```
+
+### WORKDIR
+
+```dockerfile
+# Always use absolute paths
+WORKDIR /app
+WORKDIR /app/src
+```
+
+### HEALTHCHECK
+
+```dockerfile
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost/ || exit 1
+```
+
+## Layer Optimization
+
+### Order Matters
+
+```dockerfile
+# 1. Install dependencies (changes rarely)
+COPY package.json package-lock.json ./
+RUN npm ci
+
+# 2. Copy source (changes often)
+COPY . .
+
+# 3. Build
+RUN npm run build
+```
+
+### Combine RUN Commands
+
+```dockerfile
+# Good: Single layer
+RUN apt-get update && \
+    apt-get install -y python3 && \
+    rm -rf /var/lib/apt/lists/*
+
+# Bad: Multiple layers
+RUN apt-get update
+RUN apt-get install -y python3
+RUN rm -rf /var/lib/apt/lists/*
+```
+
+## Security Best Practices
+
+### Don't Run as Root
+
+```dockerfile
+FROM node:20
+
+RUN groupadd -r nodejs && useradd -r -g nodejs nodejs
+USER nodejs
+
+COPY --chown=nodejs:nodejs . .
+```
+
+### Don't Store Secrets
+
+```dockerfile
+# Bad: Secret in image
+ENV API_KEY=secret123
+
+# Good: Pass at runtime
+# docker run -e API_KEY=secret123 myapp
+```
+
+### Use Official Images
+
+```dockerfile
+# Official and verified
+FROM nginx:1.25
+FROM postgres:16
+
+# Minimal images
+FROM gcr.io/distroless/static
+FROM alpine:3.19
+```
+
+## Example Dockerfiles
+
+### Node.js
+
+```dockerfile
+FROM node:20-slim AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM node:20-slim
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+USER node
+EXPOSE 3000
+CMD ["node", "dist/server.js"]
+```
+
+### Python
+
+```dockerfile
+FROM python:3.12-slim AS builder
+WORKDIR /app
+RUN pip install --user pipenv
+COPY Pipfile Pipfile.lock ./
+RUN pipenv install --system --deploy
+
+FROM python:3.12-slim
+WORKDIR /app
+COPY --from=builder /root/.local /root/.local
+COPY . .
+ENV PATH=/root/.local/bin:$PATH
+USER nobody
+EXPOSE 8000
+CMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]
+```
+
+### Go
+
+```dockerfile
+FROM golang:1.21-alpine AS builder
+WORKDIR /app
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+RUN CGO_ENABLED=0 GOOS=linux go build -o /app/server
+
+FROM scratch
+COPY --from=builder /app/server /server
+EXPOSE 8080
+ENTRYPOINT ["/server"]
+```

package/templates/agents/infra-engineer/docker-expert/refs/docker/index.yaml

@@ -0,0 +1,26 @@
+# Docker Guide
+
+metadata:
+  name: docker
+  description: Docker containerization reference documentation
+
+source:
+  type: external
+  origin: docker.com
+  urls:
+    - https://docs.docker.com/
+    - https://docs.docker.com/develop/develop-images/dockerfile_best-practices/
+    - https://docs.docker.com/compose/compose-file/best-practices/
+  last_fetched: "2026-01-22"
+
+documents:
+  - name: dockerfile-best-practices
+    path: ./dockerfile-best-practices.md
+    description: Dockerfile best practices
+
+  - name: compose-best-practices
+    path: ./compose-best-practices.md
+    description: Docker Compose best practices
+
+used_by:
+  - docker-expert

package/templates/agents/infra-engineer/docker-expert/refs/docker-best-practices/SKILL.md

@@ -0,0 +1,274 @@
+# Docker Best Practices Skill
+
+> **Category**: Infrastructure
+> **Source**: Internal (based on Docker Official Documentation)
+
+## Purpose
+
+Apply Docker patterns for building optimized and secure container images.
+
+## Rules
+
+### 1. Layer Optimization
+
+```yaml
+principles:
+  - Combine related RUN commands
+  - Sort multi-line arguments alphabetically
+  - Clean up in same layer
+
+patterns: |
+  # GOOD: Single layer, clean cache
+  RUN apt-get update && apt-get install -y \
+      curl \
+      git \
+      vim \
+      && rm -rf /var/lib/apt/lists/*
+
+  # BAD: Multiple layers, cache remains
+  RUN apt-get update
+  RUN apt-get install -y curl
+  RUN apt-get install -y git
+```
+
+### 2. Multi-Stage Builds
+
+```yaml
+purpose:
+  - Reduce final image size
+  - Separate build and runtime dependencies
+  - Security (no build tools in production)
+
+pattern: |
+  # Build stage
+  FROM golang:1.21 AS builder
+  WORKDIR /app
+  COPY go.mod go.sum ./
+  RUN go mod download
+  COPY . .
+  RUN CGO_ENABLED=0 go build -o /app/server ./cmd/server
+
+  # Runtime stage
+  FROM gcr.io/distroless/static:nonroot
+  COPY --from=builder /app/server /server
+  USER nonroot:nonroot
+  ENTRYPOINT ["/server"]
+```
+
+### 3. Security
+
+```yaml
+principles:
+  - Run as non-root user
+  - Pin base image versions
+  - Use minimal base images
+  - Don't store secrets in images
+
+patterns: |
+  # Pin version with digest
+  FROM node:20-slim@sha256:abc123...
+
+  # Create non-root user
+  RUN groupadd -r appgroup && useradd -r -g appgroup appuser
+  USER appuser
+
+  # Use secrets mount (BuildKit)
+  RUN --mount=type=secret,id=npmrc,target=/root/.npmrc \
+      npm install
+
+  # .dockerignore for secrets
+  # .env
+  # *.pem
+  # credentials.json
+```
+
+### 4. Image Size Reduction
+
+```yaml
+strategies:
+  - Use slim/alpine base images
+  - Remove build dependencies
+  - Use .dockerignore
+  - Multi-stage builds
+
+minimal_bases:
+  distroless: "gcr.io/distroless/static"
+  alpine: "alpine:3.19"
+  slim: "debian:12-slim"
+
+patterns: |
+  # Alpine for size
+  FROM python:3.12-alpine
+  RUN apk add --no-cache gcc musl-dev
+
+  # Distroless for security
+  FROM gcr.io/distroless/python3
+  COPY --from=builder /app /app
+```
+
+### 5. Cache Optimization
+
+```yaml
+principles:
+  - Order from least to most frequently changing
+  - Copy dependency files first
+  - Use BuildKit cache mounts
+
+patterns: |
+  # Copy dependency files first
+  COPY package.json package-lock.json ./
+  RUN npm ci
+
+  # Then copy source (changes frequently)
+  COPY . .
+  RUN npm run build
+
+  # BuildKit cache mount
+  RUN --mount=type=cache,target=/root/.cache/pip \
+      pip install -r requirements.txt
+```
+
+### 6. ENTRYPOINT vs CMD
+
+```yaml
+entrypoint:
+  purpose: Main executable
+  form: exec form ["executable"]
+
+cmd:
+  purpose: Default arguments
+  form: exec form ["arg1", "arg2"]
+
+patterns: |
+  # Fixed command with variable args
+  ENTRYPOINT ["python", "app.py"]
+  CMD ["--port", "8080"]
+
+  # docker run myapp --port 3000
+  # Executes: python app.py --port 3000
+
+  # Flexible command
+  CMD ["python", "app.py"]
+
+  # docker run myapp bash
+  # Executes: bash
+```
+
+### 7. Health Checks
+
+```yaml
+purpose: Container health monitoring
+interval: how often to check
+timeout: max time for check
+retries: failures before unhealthy
+
+pattern: |
+  HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
+      CMD curl -f http://localhost:8080/health || exit 1
+```
+
+### 8. Docker Compose
+
+```yaml
+best_practices:
+  - Use named volumes
+  - Define networks explicitly
+  - Use environment files
+  - Set resource limits
+
+pattern: |
+  version: "3.8"
+
+  services:
+    app:
+      build:
+        context: .
+        target: production
+      environment:
+        - DATABASE_URL
+      env_file:
+        - .env
+      ports:
+        - "8080:8080"
+      depends_on:
+        db:
+          condition: service_healthy
+      deploy:
+        resources:
+          limits:
+            cpus: "1"
+            memory: 512M
+      networks:
+        - backend
+
+    db:
+      image: postgres:16-alpine
+      volumes:
+        - postgres_data:/var/lib/postgresql/data
+      healthcheck:
+        test: ["CMD-SHELL", "pg_isready -U postgres"]
+        interval: 10s
+        timeout: 5s
+        retries: 5
+      networks:
+        - backend
+
+  volumes:
+    postgres_data:
+
+  networks:
+    backend:
+```
+
+### 9. Common Patterns by Language
+
+```yaml
+nodejs: |
+  FROM node:20-slim AS builder
+  WORKDIR /app
+  COPY package*.json ./
+  RUN npm ci --only=production
+
+  FROM gcr.io/distroless/nodejs20
+  WORKDIR /app
+  COPY --from=builder /app/node_modules ./node_modules
+  COPY . .
+  CMD ["server.js"]
+
+python: |
+  FROM python:3.12-slim AS builder
+  WORKDIR /app
+  RUN pip install --user -r requirements.txt
+
+  FROM python:3.12-slim
+  WORKDIR /app
+  COPY --from=builder /root/.local /root/.local
+  COPY . .
+  ENV PATH=/root/.local/bin:$PATH
+  CMD ["python", "app.py"]
+
+go: |
+  FROM golang:1.21 AS builder
+  WORKDIR /app
+  COPY go.* ./
+  RUN go mod download
+  COPY . .
+  RUN CGO_ENABLED=0 go build -o /server
+
+  FROM scratch
+  COPY --from=builder /server /server
+  ENTRYPOINT ["/server"]
+```
+
+## Application
+
+When writing Dockerfiles:
+
+1. **Always** use multi-stage builds
+2. **Always** run as non-root user
+3. **Always** pin base image versions
+4. **Prefer** minimal base images
+5. **Order** layers for cache efficiency
+6. **Clean** package caches in same layer
+7. **Use** .dockerignore
+8. **Add** health checks

package/templates/agents/infra-engineer/docker-expert/refs/docker-best-practices/index.yaml

@@ -0,0 +1,26 @@
+# Docker Best Practices Skill
+
+metadata:
+  name: docker-best-practices
+  category: infrastructure
+  description: Docker patterns for optimized containerization
+
+source:
+  type: internal
+  reference:
+    - https://docs.docker.com/
+    - https://docs.docker.com/develop/develop-images/dockerfile_best-practices/
+    - https://docs.docker.com/compose/compose-file/best-practices/
+
+provides:
+  - Layer optimization
+  - Multi-stage builds
+  - Security best practices
+  - Image size reduction
+  - Cache optimization
+  - ENTRYPOINT vs CMD
+  - Health checks
+  - Docker Compose patterns
+
+used_by:
+  - docker-expert

package/templates/agents/manager/creator/refs/rules/MAY-optimization.md

@@ -0,0 +1,93 @@
+# [MAY] Optimization Guide
+
+> **Priority**: MAY - Optional
+> **Apply when**: Basic functionality is stable
+
+## Efficiency Optimization
+
+### Parallel Processing
+```
+Apply when:
+- 3+ independent tasks
+- Each task is I/O bound
+
+Example:
+- Read multiple files simultaneously
+- Run independent searches in parallel
+```
+
+### Caching
+```
+Apply when:
+- Same data accessed repeatedly
+- Data changes infrequently
+
+Example:
+- Cache file contents
+- Reuse search results
+```
+
+### Lazy Loading
+```
+Apply when:
+- Large datasets
+- Only portion actually used
+
+Example:
+- Read only needed files
+- Stream results
+```
+
+## Token Optimization
+
+### Context Management
+```
+✓ Include only necessary info
+✓ Remove duplicates
+✓ Use summaries
+```
+
+### Response Optimization
+```
+✓ Concise expressions
+✓ Minimize code blocks
+✓ Remove unnecessary repetition
+```
+
+## Task Optimization
+
+### Batch Processing
+```
+Group similar tasks together
+Example: Edit 10 files → Process at once
+```
+
+### Incremental Processing
+```
+Process only changed parts
+Example: Full build → Incremental build
+```
+
+## Apply Criteria
+
+### Do Optimize
+```
+✓ Repetitive tasks
+✓ Clear performance bottleneck
+✓ Measurable improvement
+```
+
+### Don't Optimize
+```
+✗ One-time tasks
+✗ Already fast enough
+✗ Complexity increase outweighs benefit
+```
+
+## Caution
+
+```
+⚠ Premature optimization is root of evil
+⚠ Readability > Optimization
+⚠ No optimization without measurement
+```