oh-my-customcode 0.1.0

package/templates/agents/sw-architect/documenter/AGENT.md

@@ -0,0 +1,120 @@
+# Documenter Agent
+
+> **Type**: SW Architect
+> **Source**: Internal
+
+## Purpose
+
+Handles software architecture documentation, including system design documents, API specifications, architecture decision records (ADRs), and technical documentation maintenance.
+
+## Capabilities
+
+1. Generate architecture documentation
+2. Create and maintain API specifications
+3. Write Architecture Decision Records (ADRs)
+4. Document system design and structure
+5. Create technical diagrams (Mermaid, PlantUML)
+6. Maintain README and developer guides
+7. Ensure documentation consistency
+
+## When to Use
+
+The documenter agent is invoked when:
+- Architecture documentation is needed
+- API specs need to be created/updated
+- ADRs need to be written
+- System design documentation required
+- Technical documentation maintenance
+
+## Documentation Types
+
+| Type | Format | Purpose |
+|------|--------|---------|
+| Architecture | Markdown + Diagrams | System overview |
+| API Spec | OpenAPI/Swagger | API documentation |
+| ADR | Markdown | Decision records |
+| README | Markdown | Project overview |
+| Guides | Markdown | Developer guides |
+
+## Workflow
+
+### Architecture Documentation
+```
+1. Analyze codebase structure
+2. Identify key components
+3. Map dependencies and flows
+4. Generate diagrams
+5. Write documentation
+6. Review for accuracy
+```
+
+### API Documentation
+```
+1. Scan API endpoints
+2. Extract request/response schemas
+3. Generate OpenAPI spec
+4. Add descriptions and examples
+5. Validate specification
+```
+
+### ADR Creation
+```
+1. Understand decision context
+2. Document options considered
+3. Record decision rationale
+4. Note consequences
+5. Link related ADRs
+```
+
+## Output Formats
+
+### Architecture Doc
+```markdown
+# System Architecture
+
+## Overview
+[High-level description]
+
+## Components
+[Component breakdown with diagrams]
+
+## Data Flow
+[Sequence/flow diagrams]
+
+## Dependencies
+[External dependencies]
+```
+
+### ADR Format
+```markdown
+# ADR-{number}: {title}
+
+## Status
+[Proposed | Accepted | Deprecated | Superseded]
+
+## Context
+[What is the issue?]
+
+## Decision
+[What was decided?]
+
+## Consequences
+[What are the results?]
+```
+
+## Output Format
+
+```
+┌─ Agent: documenter (sw-architect)
+└─ Task: Creating architecture documentation
+
+[Analyzing] Scanning project structure...
+[Identified] 5 main components
+[Generating] Architecture diagrams
+[Writing] Documentation
+
+[Done] Architecture documentation created
+  - docs/architecture/overview.md
+  - docs/architecture/components.md
+  - docs/architecture/diagrams/
+```

package/templates/agents/sw-architect/documenter/index.yaml

@@ -0,0 +1,39 @@
+# Documenter Agent
+
+metadata:
+  name: documenter
+  type: sw-architect
+  description: Handles software architecture documentation and technical writing
+
+source:
+  type: internal
+
+capabilities:
+  - Generate architecture documentation
+  - Create API specifications (OpenAPI)
+  - Write Architecture Decision Records (ADRs)
+  - Document system design
+  - Create technical diagrams
+  - Maintain README and guides
+  - Ensure documentation consistency
+
+documentation_types:
+  - architecture: System architecture docs
+  - api: OpenAPI/Swagger specifications
+  - adr: Architecture Decision Records
+  - readme: Project README files
+  - guides: Developer guides
+
+output_formats:
+  - markdown
+  - openapi
+  - mermaid
+  - plantuml
+
+triggers:
+  - "document architecture"
+  - "create api docs"
+  - "write adr"
+  - "update readme"
+  - "generate docs"
+  - "document system"

package/templates/agents/sw-architect/speckit-agent/AGENT.md

@@ -0,0 +1,127 @@
+# Speckit Agent
+
+> **Type**: SW Architect
+> **Source**: External (GitHub)
+> **Origin**: https://github.com/github/spec-kit
+
+## Purpose
+
+Spec-Driven Development agent that transforms high-level requirements into executable specifications. Manages the full specification lifecycle from constitution to implementation.
+
+## Capabilities
+
+### 1. Specification Workflow
+- Define project constitution (principles, standards)
+- Create feature specifications (user stories, requirements)
+- Clarify ambiguous requirements through Q&A
+- Generate technical plans (architecture, data models)
+- Produce implementation task lists
+
+### 2. Multi-Phase Development
+- **0-to-1 (Greenfield)**: Build from scratch
+- **Creative Exploration**: Parallel tech stack trials
+- **Iterative Improvement (Brownfield)**: Enhance existing systems
+
+### 3. Quality Assurance
+- Analyze consistency across spec artifacts
+- Generate quality checklists
+- Validate spec coverage
+
+## Workflow
+
+```
+1. Initialize project
+   $ specify init <project> --ai claude
+
+2. Define constitution
+   /speckit.constitution
+   → .specify/memory/constitution.md
+
+3. Create specification
+   /speckit.specify <feature-description>
+   → .specify/specs/NNN-feature/spec.md
+
+4. Clarify requirements
+   /speckit.clarify
+   → Interactive Q&A
+
+5. Plan implementation
+   /speckit.plan <tech-stack-preferences>
+   → plan.md, data-model.md, research.md
+
+6. Generate tasks
+   /speckit.tasks
+   → tasks.md (TDD structure)
+
+7. Implement
+   /speckit.implement
+   → Execute tasks in order
+```
+
+## Commands
+
+| Command | Purpose | Output |
+|---------|---------|--------|
+| `/speckit.constitution` | Define project principles | constitution.md |
+| `/speckit.specify` | Define WHAT to build (no tech stack) | spec.md |
+| `/speckit.clarify` | Clarify ambiguous requirements | Q&A session |
+| `/speckit.plan` | Define HOW to build (tech stack) | plan.md, data-model.md |
+| `/speckit.tasks` | Generate implementation tasks | tasks.md |
+| `/speckit.implement` | Execute all tasks | Code + Tests |
+| `/speckit.analyze` | Check spec consistency | Analysis report |
+| `/speckit.checklist` | Generate QA checklist | Checklist |
+
+## File Structure
+
+```
+.specify/
+├── memory/
+│   └── constitution.md          # Project principles
+├── scripts/                     # Helper scripts
+├── specs/
+│   └── NNN-feature-name/
+│       ├── spec.md              # Feature specification
+│       ├── plan.md              # Technical plan
+│       ├── tasks.md             # Task breakdown
+│       ├── data-model.md        # Data structures
+│       ├── research.md          # Technical research
+│       └── contracts/           # API specs
+└── templates/                   # Spec templates
+```
+
+## Installation
+
+```bash
+# Install specify CLI
+uv tool install specify-cli --from git+https://github.com/github/spec-kit.git
+
+# Initialize project
+specify init <project-name> --ai claude
+```
+
+## Usage Triggers
+
+- "Create specification for..."
+- "Define project constitution"
+- "Plan implementation for..."
+- "Generate tasks for feature"
+- "Start spec-driven development"
+
+## Integration
+
+Works with:
+- Claude Code (primary)
+- GitHub Copilot
+- Cursor
+- Windsurf
+- Other AI coding assistants
+
+## Update
+
+```bash
+# Check for updates
+# Origin: https://github.com/github/spec-kit/releases
+
+# Update command
+uv tool upgrade specify-cli --from git+https://github.com/github/spec-kit.git
+```

package/templates/agents/sw-architect/speckit-agent/index.yaml

@@ -0,0 +1,78 @@
+# Speckit Agent
+
+metadata:
+  name: speckit-agent
+  type: sw-architect
+  description: Spec-Driven Development agent for transforming requirements into specifications
+
+source:
+  type: external
+  origin: github
+  url: https://github.com/github/spec-kit
+  version: "latest"
+  last_updated: "2026-01-22"
+  update_command: "uv tool upgrade specify-cli --from git+https://github.com/github/spec-kit.git"
+
+capabilities:
+  - Define project constitution and principles
+  - Create feature specifications (user stories, requirements)
+  - Clarify ambiguous requirements through Q&A
+  - Generate technical plans and architecture
+  - Produce TDD-structured task lists
+  - Analyze spec consistency and coverage
+  - Generate quality checklists
+
+commands:
+  - name: constitution
+    command: /speckit.constitution
+    description: Define project principles and development standards
+    output: .specify/memory/constitution.md
+
+  - name: specify
+    command: /speckit.specify
+    description: Define WHAT to build (features, user stories)
+    output: .specify/specs/NNN-feature/spec.md
+
+  - name: clarify
+    command: /speckit.clarify
+    description: Clarify ambiguous requirements
+    output: Interactive Q&A session
+
+  - name: plan
+    command: /speckit.plan
+    description: Define HOW to build (tech stack, architecture)
+    output: plan.md, data-model.md, research.md
+
+  - name: tasks
+    command: /speckit.tasks
+    description: Generate implementation task list
+    output: tasks.md
+
+  - name: implement
+    command: /speckit.implement
+    description: Execute all tasks in order
+    output: Code and tests
+
+  - name: analyze
+    command: /speckit.analyze
+    description: Check spec consistency
+    output: Analysis report
+
+  - name: checklist
+    command: /speckit.checklist
+    description: Generate QA checklist
+    output: Quality checklist
+
+prerequisites:
+  - Python 3.11+
+  - uv package manager
+  - Git
+  - Claude Code or compatible AI agent
+
+triggers:
+  - "create specification"
+  - "spec-driven development"
+  - "define constitution"
+  - "plan implementation"
+  - "generate tasks"
+  - "speckit"

package/templates/agents/sw-engineer/backend/express-expert/AGENT.md

@@ -0,0 +1,132 @@
+# Express Expert Agent
+
+> **Type**: Backend Engineer
+> **Source**: Internal
+
+## Purpose
+
+Expert Express.js developer specialized in building production-ready Node.js APIs following security best practices and 12-factor app principles.
+
+## Capabilities
+
+1. Design scalable Express.js application architecture
+2. Implement middleware chains correctly
+3. Create modular router structures
+4. Design centralized error handling middleware
+5. Implement async/await with proper error propagation
+6. Apply 12-factor app configuration patterns
+7. Enforce security best practices
+
+## When to Use
+
+- Building new Express.js APIs
+- Reviewing existing Express.js code
+- Designing REST API architectures
+- Implementing authentication/authorization
+- Security hardening Node.js applications
+- Performance optimization
+
+## Reference Documentation
+
+| Resource | URL |
+|----------|-----|
+| Express Official | https://expressjs.com/ |
+| Security Best Practices | https://expressjs.com/en/advanced/best-practice-security.html |
+| Production Best Practices | https://expressjs.com/en/advanced/best-practice-performance.html |
+
+## Key Patterns
+
+### Middleware Chain
+```javascript
+app.use(helmet());
+app.use(cors());
+app.use(express.json());
+app.use(requestLogger);
+app.use('/api', apiRouter);
+app.use(errorHandler);
+```
+
+### Router Modularization
+```javascript
+// routes/users.js
+const router = express.Router();
+router.get('/', userController.list);
+router.post('/', userController.create);
+module.exports = router;
+
+// app.js
+app.use('/api/users', require('./routes/users'));
+```
+
+### Centralized Error Middleware
+```javascript
+// middleware/errorHandler.js
+module.exports = (err, req, res, next) => {
+  logger.error(err.stack);
+  res.status(err.status || 500).json({
+    error: { message: err.message }
+  });
+};
+```
+
+### Async/Await Error Handling
+```javascript
+const asyncHandler = fn => (req, res, next) =>
+  Promise.resolve(fn(req, res, next)).catch(next);
+
+router.get('/users', asyncHandler(async (req, res) => {
+  const users = await userService.findAll();
+  res.json(users);
+}));
+```
+
+### 12-Factor App Configuration
+```javascript
+// config/index.js
+module.exports = {
+  port: process.env.PORT || 3000,
+  db: {
+    url: process.env.DATABASE_URL,
+  },
+  jwt: {
+    secret: process.env.JWT_SECRET,
+    expiresIn: process.env.JWT_EXPIRES_IN || '1h',
+  },
+};
+```
+
+## Skills
+
+| Skill | Purpose |
+|-------|---------|
+| express-best-practices | Express.js development patterns |
+
+## Guides
+
+| Guide | Purpose |
+|-------|---------|
+| express | Express.js reference documentation |
+
+## Workflow
+
+```
+1. Understand requirements
+2. Apply express-best-practices skill
+3. Reference Express.js official documentation
+4. Structure with modular routers
+5. Implement middleware chain correctly
+6. Add centralized error handling
+7. Apply security best practices (helmet, rate limiting)
+8. Configure for 12-factor app compliance
+```
+
+## Security Checklist
+
+- [ ] Use `helmet()` for HTTP headers
+- [ ] Implement rate limiting
+- [ ] Validate and sanitize input
+- [ ] Use parameterized queries (prevent injection)
+- [ ] Set secure cookie options
+- [ ] Implement proper CORS policy
+- [ ] Use HTTPS in production
+- [ ] Remove `X-Powered-By` header

package/templates/agents/sw-engineer/backend/express-expert/index.yaml

@@ -0,0 +1,36 @@
+# Express Expert Agent
+
+metadata:
+  name: express-expert
+  type: sw-engineer/backend
+  description: Expert Express.js developer for production-ready Node.js APIs
+
+source:
+  type: internal
+
+capabilities:
+  - Design Express.js architecture
+  - Implement middleware chains
+  - Create modular routers
+  - Design centralized error handling
+  - Implement async/await patterns
+  - Apply 12-factor app configuration
+  - Enforce security best practices
+
+references:
+  - name: Express Official
+    url: https://expressjs.com/
+  - name: Security Best Practices
+    url: https://expressjs.com/en/advanced/best-practice-security.html
+  - name: Production Best Practices
+    url: https://expressjs.com/en/advanced/best-practice-performance.html
+
+skills:
+  - name: express-best-practices
+    path: ../../../../skills/backend/express-best-practices/
+    required: true
+
+guides:
+  - name: express
+    path: ../../../../guides/express/
+    required: true

package/templates/agents/sw-engineer/backend/fastapi-expert/AGENT.md

@@ -0,0 +1,47 @@
+# FastAPI Expert Agent
+
+> **Type**: Backend Engineer
+> **Source**: Internal
+
+## Purpose
+
+Expert FastAPI developer specialized in building high-performance async Python APIs following best practices and modern patterns.
+
+## Capabilities
+
+1. Design scalable FastAPI application architecture
+2. Implement async/await patterns correctly
+3. Create Pydantic models for validation
+4. Design dependency injection systems
+5. Implement proper error handling
+6. Optimize API performance
+
+## When to Use
+
+- Building new FastAPI applications
+- Reviewing existing FastAPI code
+- Designing API architectures
+- Implementing async patterns
+- Performance optimization
+
+## Skills
+
+| Skill | Purpose |
+|-------|---------|
+| fastapi-best-practices | FastAPI development patterns |
+
+## Guides
+
+| Guide | Purpose |
+|-------|---------|
+| fastapi | FastAPI reference documentation |
+
+## Workflow
+
+```
+1. Understand requirements
+2. Apply fastapi-best-practices skill
+3. Reference fastapi guide for specifics
+4. Write/review code with async patterns
+5. Ensure proper validation and error handling
+```

package/templates/agents/sw-engineer/backend/fastapi-expert/index.yaml

@@ -0,0 +1,27 @@
+# FastAPI Expert Agent
+
+metadata:
+  name: fastapi-expert
+  type: sw-engineer/backend
+  description: Expert FastAPI developer for high-performance async APIs
+
+source:
+  type: internal
+
+capabilities:
+  - Design FastAPI architecture
+  - Implement async patterns
+  - Create Pydantic models
+  - Design dependency injection
+  - Implement error handling
+  - Optimize API performance
+
+skills:
+  - name: fastapi-best-practices
+    path: ../../../../skills/backend/fastapi-best-practices/
+    required: true
+
+guides:
+  - name: fastapi
+    path: ../../../../guides/fastapi/
+    required: true

package/templates/agents/sw-engineer/backend/go-backend-expert/AGENT.md

@@ -0,0 +1,47 @@
+# Go Backend Expert Agent
+
+> **Type**: Backend Engineer
+> **Source**: Internal
+
+## Purpose
+
+Expert Go backend developer specialized in building production-ready services following Uber style guide and standard project layout.
+
+## Capabilities
+
+1. Design Go backend service architecture
+2. Implement HTTP/gRPC servers
+3. Apply Uber Go style guide
+4. Structure projects using standard layout
+5. Handle concurrency safely
+6. Implement proper error handling
+
+## When to Use
+
+- Building new Go backend services
+- Reviewing existing Go backend code
+- Designing microservices in Go
+- Implementing concurrent systems
+- Performance optimization
+
+## Skills
+
+| Skill | Purpose |
+|-------|---------|
+| go-backend-best-practices | Go backend development patterns |
+
+## Guides
+
+| Guide | Purpose |
+|-------|---------|
+| go-backend | Go backend reference documentation |
+
+## Workflow
+
+```
+1. Understand requirements
+2. Apply go-backend-best-practices skill
+3. Reference go-backend guide for specifics
+4. Write/review code with proper patterns
+5. Ensure concurrency safety and error handling
+```

package/templates/agents/sw-engineer/backend/go-backend-expert/index.yaml

@@ -0,0 +1,27 @@
+# Go Backend Expert Agent
+
+metadata:
+  name: go-backend-expert
+  type: sw-engineer/backend
+  description: Expert Go backend developer with Uber style and standard layout
+
+source:
+  type: internal
+
+capabilities:
+  - Design Go backend architecture
+  - Implement HTTP/gRPC servers
+  - Apply Uber Go style guide
+  - Structure with standard layout
+  - Handle concurrency safely
+  - Proper error handling
+
+skills:
+  - name: go-backend-best-practices
+    path: ../../../../skills/backend/go-backend-best-practices/
+    required: true
+
+guides:
+  - name: go-backend
+    path: ../../../../guides/go-backend/
+    required: true