oh-my-customcode 0.1.4 → 0.2.0

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

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

@@ -1,26 +0,0 @@
-# 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/AGENT.md

@@ -1,274 +0,0 @@
-# Agent Creator
-
-> **Type**: Manager
-> **Source**: Internal
-
-## Purpose
-
-Create new agents following the design guidelines defined in R006 (MUST-agent-design.md).
-**Automatically research authoritative references** before agent creation to ensure high-quality knowledge base.
-
-## Capabilities
-
-1. **Research authoritative references** for target technology
-2. Generate agent folder structure
-3. Create AGENT.md with proper format
-4. Create index.yaml with metadata
-5. Set up refs/ with symlinks
-6. Update agents/index.yaml registry
-7. Handle external agent source tracking
-
-## Required Inputs
-
-| Input | Required | Description |
-|-------|----------|-------------|
-| name | Yes | Agent name in kebab-case |
-| type | Yes | worker, orchestrator, or manager |
-| purpose | Yes | What the agent does |
-| technology | No | Target technology/language/framework (auto-detected from name if not provided) |
-| source_url | No | GitHub URL if external |
-| skills | No | Required skill names |
-| guides | No | Reference guide names |
-
-## Workflow
-
-```
-0. RESEARCH PHASE (NEW - MANDATORY for language/framework agents)
-   ┌─────────────────────────────────────────────────────────────┐
-   │ For technology/language/framework agents, MUST research     │
-   │ authoritative references BEFORE creating the agent.         │
-   └─────────────────────────────────────────────────────────────┘
-
-   a. Identify the target technology from agent name/purpose
-      - golang-expert → Go
-      - springboot-expert → Spring Boot
-      - react-expert → React
-
-   b. Research authoritative documentation (WebSearch/WebFetch)
-      Use the following criteria:
-
-      ╔════════════════════════════════════════════════════════════╗
-      ║  RESEARCH CRITERIA                                         ║
-      ║                                                            ║
-      ║  Priority:                                                 ║
-      ║  1. Official documentation (highest priority)              ║
-      ║  2. Semi-official style guides/best practices             ║
-      ║  3. Widely-recognized community standards                  ║
-      ║                                                            ║
-      ║  Exclusions:                                               ║
-      ║  - Simple tutorials                                        ║
-      ║  - Beginner guides                                         ║
-      ║  - Outdated documentation                                  ║
-      ║                                                            ║
-      ║  Target: "Effective Go"-equivalent document                ║
-      ║  = Canonical reference for idiomatic usage                 ║
-      ╚════════════════════════════════════════════════════════════╝
-
-   c. Organize findings into categories:
-      - Official Reference: Language/framework official docs
-      - Effective [X]: Closest equivalent to "Effective Go"
-      - Style Guide: Official or de-facto standard style guide
-      - Best Practices: Production-ready patterns
-      - API Reference: Comprehensive API documentation
-
-   d. Format each reference as:
-      [Title](URL) - One-line description of what it covers
-
-   e. Store research results in:
-      agents/{type}/{name}/refs/REFERENCES.md
-
-1. Validate inputs
-   - Name is kebab-case
-   - Type is valid
-   - Purpose is clear
-
-2. Create structure
-   agents/{type}/{name}/
-   ├── AGENT.md
-   ├── index.yaml
-   └── refs/
-       └── REFERENCES.md  ← Research results
-
-3. Generate AGENT.md
-   - Purpose section
-   - Capabilities overview (not details)
-   - Required skills (by reference)
-   - Workflow description
-   - Source info (if external)
-   - **Key References section** (from research)
-
-4. Generate index.yaml
-   - Metadata block
-   - Source block (if external)
-   - Skills references
-   - Capabilities list
-   - Triggers
-   - **references block** (from research)
-
-5. Create refs/ symlinks
-   - Link to required skills
-   - Link to required guides
-
-6. Update registry
-   - Add to agents/index.yaml
-```
-
-## Research Prompt Template
-
-When researching a technology, use this prompt pattern:
-
-```
-Research authoritative documentation for [TECHNOLOGY].
-
-Find documents similar to Go's "Effective Go" - canonical references that cover:
-- Idiomatic usage patterns
-- Best practices for production code
-- Official style guidelines
-- Core API reference
-
-Criteria:
-- Official documentation takes highest priority
-- Only include widely-recognized authoritative sources
-- Exclude simple tutorials and beginner guides
-- Each item: [Title](URL) - brief description
-- Identify which document is closest to "Effective Go"
-
-Structure findings by:
-1. Official Reference
-2. Effective [X] (canonical idiomatic guide)
-3. Style Guide
-4. Best Practices
-5. API Reference
-```
-
-## Output Structure
-
-### REFERENCES.md (Research Results)
-
-```markdown
-# [Technology] Authoritative References
-
-## Effective [X] (Canonical Idiomatic Guide)
-> **Closest to "Effective Go"**
-
-[Document Title](URL) - One-line description
-
-## Official Reference
-- [Official Docs](URL) - Core documentation
-- [Language Spec](URL) - Formal specification
-
-## Style Guide
-- [Style Guide](URL) - Coding conventions
-
-## Best Practices
-- [Best Practices Doc](URL) - Production patterns
-
-## API Reference
-- [API Docs](URL) - Comprehensive API documentation
-```
-
-### For Internal Agent (index.yaml)
-
-```yaml
-metadata:
-  name: {name}
-  type: {type}
-  description: {purpose}
-
-source:
-  type: internal
-
-references:
-  effective: "URL to Effective X equivalent"
-  official: "URL to official docs"
-  style_guide: "URL to style guide"
-
-capabilities:
-  - ...
-
-triggers:
-  - ...
-```
-
-### For External Agent (index.yaml)
-
-```yaml
-metadata:
-  name: {name}
-  type: {type}
-  description: {purpose}
-
-source:
-  type: external
-  origin: github
-  url: {source_url}
-  version: "1.0.0"
-  last_updated: {today}
-  update_command: "..."
-
-references:
-  effective: "..."
-  official: "..."
-
-skills:
-  - name: ...
-    category: ...
-    path: ...
-```
-
-## Rules Applied
-
-- R000: All files in English
-- R006: Separation of concerns
-  - AGENT.md: Role and capabilities only
-  - Skills: Detailed instructions (separate)
-  - Guides: Reference docs (separate)
-
-## Usage Example
-
-```
-User: "react-expert 에이전트를 만들어줘"
-
-Creator Workflow:
-
-0. RESEARCH PHASE
-   [creator → WebSearch] "React official documentation best practices"
-   [creator → WebSearch] "React style guide canonical reference"
-
-   Research Results:
-   ┌────────────────────────────────────────────────────────────┐
-   │ Effective React (closest to Effective Go):                 │
-   │ → React Docs - Thinking in React                          │
-   │   https://react.dev/learn/thinking-in-react               │
-   │                                                            │
-   │ Official Reference:                                        │
-   │ → React Documentation                                      │
-   │   https://react.dev                                        │
-   │                                                            │
-   │ Style Guide:                                               │
-   │ → Airbnb React/JSX Style Guide                            │
-   │   https://github.com/airbnb/javascript/tree/master/react  │
-   └────────────────────────────────────────────────────────────┘
-
-1. CREATE PHASE
-   [creator → Write] agents/sw-engineer/frontend/react-expert/AGENT.md
-   [creator → Write] agents/sw-engineer/frontend/react-expert/index.yaml
-   [creator → Write] agents/sw-engineer/frontend/react-expert/refs/REFERENCES.md
-
-2. REGISTRY UPDATE
-   [creator → Edit] agents/index.yaml
-
-Result:
-  agents/sw-engineer/frontend/react-expert/
-  ├── AGENT.md           (with Key References section)
-  ├── index.yaml         (with references block)
-  └── refs/
-      └── REFERENCES.md  (full research results)
-```
-
-## Skip Research Conditions
-
-Research phase can be skipped when:
-- Agent is not technology/language specific (e.g., orchestrator)
-- User explicitly provides reference URLs
-- Agent is pure system/utility type (e.g., naggy, memory-keeper)

package/templates/agents/manager/creator/index.yaml

@@ -1,66 +0,0 @@
-# Agent Creator
-
-metadata:
-  name: creator
-  type: manager
-  description: Creates new agents with automatic authoritative reference research
-
-source:
-  type: internal
-
-capabilities:
-  - Research authoritative documentation for target technology
-  - Find "Effective Go"-equivalent canonical references
-  - Create agent structure (AGENT.md, index.yaml, refs/)
-  - Separate concerns (agent vs skills vs guides)
-  - Handle external agent integration
-  - Generate proper index entries
-
-required_rules:
-  - R000: Language Policy
-  - R006: Agent Design Rules
-
-required_tools:
-  - WebSearch: Research official documentation
-  - WebFetch: Fetch and verify documentation URLs
-  - Write: Create agent files
-  - Edit: Update registry
-
-triggers:
-  - "create agent"
-  - "new agent"
-  - "add agent"
-  - "make agent"
-
-inputs:
-  required:
-    - name: Agent name (kebab-case)
-    - type: worker | orchestrator | manager
-    - purpose: What the agent does
-  optional:
-    - technology: Target technology/language/framework (auto-detected if not provided)
-    - source_url: GitHub URL for external agents
-    - skills: List of required skills
-    - guides: List of reference guides
-
-workflow:
-  phase_0_research:
-    description: Research authoritative references (MANDATORY for tech agents)
-    criteria:
-      priority:
-        - Official documentation (highest)
-        - Semi-official style guides
-        - Widely-recognized community standards
-      exclusions:
-        - Simple tutorials
-        - Beginner guides
-        - Outdated docs
-      target: "Effective Go"-equivalent canonical reference
-    output: refs/REFERENCES.md
-
-  phase_1_create:
-    description: Create agent structure with research results
-    output:
-      - AGENT.md (with Key References section)
-      - index.yaml (with references block)
-      - refs/REFERENCES.md