oh-my-customcode 0.1.2 → 0.1.4

package/templates/agents/infra-engineer/aws-expert/refs/aws/common-patterns.md

@@ -0,0 +1,169 @@
+# AWS Common Architecture Patterns
+
+> Source: https://aws.amazon.com/architecture/
+
+## Web Application (Three-Tier)
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                         Internet                             │
+└────────────────────────────┬────────────────────────────────┘
+                             │
+┌────────────────────────────┴────────────────────────────────┐
+│                     CloudFront (CDN)                         │
+│                         + WAF                                │
+└────────────────────────────┬────────────────────────────────┘
+                             │
+┌────────────────────────────┴────────────────────────────────┐
+│                  Application Load Balancer                   │
+│                    (Public Subnets)                         │
+└────────────────────────────┬────────────────────────────────┘
+                             │
+┌────────────────────────────┴────────────────────────────────┐
+│              ECS Fargate / EC2 Auto Scaling                  │
+│                   (Private Subnets)                         │
+│                  + ElastiCache (Redis)                      │
+└────────────────────────────┬────────────────────────────────┘
+                             │
+┌────────────────────────────┴────────────────────────────────┐
+│                  RDS Aurora (Multi-AZ)                       │
+│                    (Private Subnets)                        │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Serverless API
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                        Client                                │
+└────────────────────────────┬────────────────────────────────┘
+                             │
+┌────────────────────────────┴────────────────────────────────┐
+│                      API Gateway                             │
+│                    (REST/HTTP API)                          │
+└────────────────────────────┬────────────────────────────────┘
+                             │
+         ┌───────────────────┼───────────────────┐
+         │                   │                   │
+┌────────┴────────┐ ┌───────┴────────┐ ┌───────┴────────┐
+│     Lambda      │ │    Lambda      │ │    Lambda      │
+│   (Get User)    │ │  (Create User) │ │  (List Users)  │
+└────────┬────────┘ └───────┬────────┘ └───────┬────────┘
+         │                   │                   │
+         └───────────────────┼───────────────────┘
+                             │
+┌────────────────────────────┴────────────────────────────────┐
+│                       DynamoDB                               │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Event-Driven Architecture
+
+```
+┌──────────────┐    ┌──────────────┐    ┌──────────────┐
+│   Producer   │───▶│   EventBridge│───▶│   Consumer   │
+│  (Lambda)    │    │    (Events)  │    │  (Lambda)    │
+└──────────────┘    └──────┬───────┘    └──────────────┘
+                           │
+         ┌─────────────────┼─────────────────┐
+         │                 │                 │
+         ▼                 ▼                 ▼
+┌──────────────┐  ┌──────────────┐  ┌──────────────┐
+│   SQS Queue  │  │  SNS Topic   │  │ Step Function│
+└──────────────┘  └──────────────┘  └──────────────┘
+```
+
+## Microservices
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    API Gateway / ALB                         │
+└────────────────────────────┬────────────────────────────────┘
+                             │
+    ┌────────────────────────┼────────────────────────┐
+    │                        │                        │
+┌───┴───┐               ┌────┴────┐              ┌────┴────┐
+│Service│               │ Service │              │ Service │
+│   A   │               │    B    │              │    C    │
+│(ECS)  │               │ (Lambda)│              │  (EKS)  │
+└───┬───┘               └────┬────┘              └────┬────┘
+    │                        │                        │
+    └────────────────────────┼────────────────────────┘
+                             │
+                    ┌────────┴────────┐
+                    │    Service Mesh │
+                    │   (App Mesh)    │
+                    └─────────────────┘
+```
+
+## Data Lake
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│                      Data Sources                             │
+│  (Databases, APIs, IoT, Logs, Streams)                       │
+└────────────────────────────┬─────────────────────────────────┘
+                             │
+┌────────────────────────────┴─────────────────────────────────┐
+│                    Ingestion Layer                            │
+│  (Kinesis, DMS, AppFlow, Transfer Family)                    │
+└────────────────────────────┬─────────────────────────────────┘
+                             │
+┌────────────────────────────┴─────────────────────────────────┐
+│                     Storage Layer                             │
+│              S3 (Raw → Processed → Curated)                  │
+│                    + Lake Formation                           │
+└────────────────────────────┬─────────────────────────────────┘
+                             │
+┌────────────────────────────┴─────────────────────────────────┐
+│                   Processing Layer                            │
+│        (Glue, EMR, Athena, Redshift Spectrum)                │
+└────────────────────────────┬─────────────────────────────────┘
+                             │
+┌────────────────────────────┴─────────────────────────────────┐
+│                   Consumption Layer                           │
+│           (QuickSight, SageMaker, APIs)                      │
+└──────────────────────────────────────────────────────────────┘
+```
+
+## CI/CD Pipeline
+
+```
+┌──────────────┐    ┌──────────────┐    ┌──────────────┐
+│   GitHub /   │───▶│  CodePipeline│───▶│  CodeBuild   │
+│ CodeCommit   │    │   (Source)   │    │   (Build)    │
+└──────────────┘    └──────────────┘    └──────┬───────┘
+                                               │
+                         ┌─────────────────────┴─────────────────────┐
+                         │                                           │
+                         ▼                                           ▼
+                ┌──────────────┐                            ┌──────────────┐
+                │     ECR      │                            │     S3       │
+                │  (Container) │                            │  (Artifact)  │
+                └──────┬───────┘                            └──────┬───────┘
+                       │                                           │
+                       └─────────────────┬─────────────────────────┘
+                                         │
+                                         ▼
+                               ┌──────────────────┐
+                               │   CodeDeploy     │
+                               │  (Blue/Green)    │
+                               └────────┬─────────┘
+                                        │
+               ┌────────────────────────┼────────────────────────┐
+               │                        │                        │
+               ▼                        ▼                        ▼
+        ┌──────────┐            ┌──────────┐            ┌──────────┐
+        │   Dev    │            │  Stage   │            │   Prod   │
+        │   ECS    │            │   ECS    │            │   ECS    │
+        └──────────┘            └──────────┘            └──────────┘
+```
+
+## Disaster Recovery
+
+| Strategy | RTO | RPO | Cost |
+|----------|-----|-----|------|
+| Backup & Restore | Hours | Hours | $ |
+| Pilot Light | Minutes-Hours | Minutes | $$ |
+| Warm Standby | Minutes | Seconds | $$$ |
+| Multi-Site Active | Near Zero | Near Zero | $$$$ |

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

@@ -0,0 +1,26 @@
+# AWS Guide
+
+metadata:
+  name: aws
+  description: AWS cloud reference documentation
+
+source:
+  type: external
+  origin: aws.amazon.com
+  urls:
+    - https://docs.aws.amazon.com/wellarchitected/latest/framework/welcome.html
+    - https://docs.aws.amazon.com/
+    - https://aws.amazon.com/architecture/
+  last_fetched: "2026-01-22"
+
+documents:
+  - name: well-architected
+    path: ./well-architected.md
+    description: AWS Well-Architected Framework summary
+
+  - name: common-patterns
+    path: ./common-patterns.md
+    description: Common AWS architecture patterns
+
+used_by:
+  - aws-expert

package/templates/agents/infra-engineer/aws-expert/refs/aws/well-architected.md

@@ -0,0 +1,143 @@
+# AWS Well-Architected Framework
+
+> Source: https://docs.aws.amazon.com/wellarchitected/
+
+## Overview
+
+The AWS Well-Architected Framework helps you understand the pros and cons of decisions you make while building systems on AWS.
+
+## Six Pillars
+
+### 1. Operational Excellence
+
+Focus on running and monitoring systems to deliver business value.
+
+**Design Principles:**
+- Perform operations as code
+- Make frequent, small, reversible changes
+- Refine operations procedures frequently
+- Anticipate failure
+- Learn from operational failures
+
+**Key Services:**
+- AWS CloudFormation
+- AWS Config
+- Amazon CloudWatch
+- AWS Systems Manager
+
+### 2. Security
+
+Protect information, systems, and assets.
+
+**Design Principles:**
+- Implement strong identity foundation
+- Enable traceability
+- Apply security at all layers
+- Automate security best practices
+- Protect data in transit and at rest
+- Keep people away from data
+- Prepare for security events
+
+**Key Services:**
+- AWS IAM
+- AWS KMS
+- AWS WAF
+- Amazon GuardDuty
+- AWS Security Hub
+
+### 3. Reliability
+
+Ensure workload performs correctly and consistently.
+
+**Design Principles:**
+- Automatically recover from failure
+- Test recovery procedures
+- Scale horizontally
+- Stop guessing capacity
+- Manage change through automation
+
+**Key Services:**
+- Amazon Route 53
+- Elastic Load Balancing
+- Auto Scaling
+- AWS Backup
+
+### 4. Performance Efficiency
+
+Use computing resources efficiently.
+
+**Design Principles:**
+- Democratize advanced technologies
+- Go global in minutes
+- Use serverless architectures
+- Experiment more often
+- Consider mechanical sympathy
+
+**Key Services:**
+- Amazon EC2 Auto Scaling
+- AWS Lambda
+- Amazon ElastiCache
+- Amazon CloudFront
+
+### 5. Cost Optimization
+
+Avoid unnecessary costs.
+
+**Design Principles:**
+- Implement cloud financial management
+- Adopt consumption model
+- Measure overall efficiency
+- Stop spending money on undifferentiated heavy lifting
+- Analyze and attribute expenditure
+
+**Key Services:**
+- AWS Cost Explorer
+- AWS Budgets
+- AWS Trusted Advisor
+- Savings Plans
+
+### 6. Sustainability
+
+Minimize environmental impacts.
+
+**Design Principles:**
+- Understand your impact
+- Establish sustainability goals
+- Maximize utilization
+- Anticipate and adopt efficient offerings
+- Use managed services
+- Reduce downstream impact
+
+## Well-Architected Review
+
+### Questions to Ask
+
+**Operational Excellence:**
+- How do you manage and automate changes?
+- How do you respond to unplanned events?
+- How do you evolve operations?
+
+**Security:**
+- How do you manage identities?
+- How do you detect security events?
+- How do you protect your network?
+
+**Reliability:**
+- How do you manage service quotas?
+- How does your system adapt to demand?
+- How do you back up data?
+
+**Performance Efficiency:**
+- How do you select compute resources?
+- How do you select storage solutions?
+- How do you configure networking?
+
+**Cost Optimization:**
+- How do you manage usage?
+- How do you monitor cost?
+- How do you decommission resources?
+
+**Sustainability:**
+- How do you select efficient hardware?
+- How do you reduce software impact?
+- How do you reduce data movement?

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

@@ -0,0 +1,279 @@
+# AWS Best Practices Skill
+
+> **Category**: Infrastructure
+> **Source**: Internal (based on AWS Well-Architected Framework)
+
+## Purpose
+
+Apply AWS patterns for building scalable, secure, and cost-effective cloud infrastructure.
+
+## Well-Architected Framework Pillars
+
+### 1. Operational Excellence
+
+```yaml
+principles:
+  - Perform operations as code
+  - Make frequent, small, reversible changes
+  - Refine operations procedures frequently
+  - Anticipate failure
+  - Learn from all operational failures
+
+practices:
+  - Use CloudFormation/CDK for IaC
+  - Implement CI/CD pipelines
+  - Use CloudWatch for monitoring
+  - Set up alarms and dashboards
+  - Document runbooks
+```
+
+### 2. Security
+
+```yaml
+principles:
+  - Implement strong identity foundation
+  - Enable traceability
+  - Apply security at all layers
+  - Automate security best practices
+  - Protect data in transit and at rest
+  - Keep people away from data
+  - Prepare for security events
+
+iam:
+  - Use least privilege principle
+  - Never use root account for daily tasks
+  - Enable MFA for all users
+  - Use IAM roles for services
+  - Rotate credentials regularly
+
+patterns: |
+  # IAM Policy - Least Privilege
+  {
+    "Version": "2012-10-17",
+    "Statement": [{
+      "Effect": "Allow",
+      "Action": [
+        "s3:GetObject",
+        "s3:PutObject"
+      ],
+      "Resource": "arn:aws:s3:::my-bucket/*",
+      "Condition": {
+        "IpAddress": {
+          "aws:SourceIp": "10.0.0.0/8"
+        }
+      }
+    }]
+  }
+```
+
+### 3. Reliability
+
+```yaml
+principles:
+  - Automatically recover from failure
+  - Test recovery procedures
+  - Scale horizontally
+  - Stop guessing capacity
+  - Manage change through automation
+
+practices:
+  - Multi-AZ deployments
+  - Auto Scaling groups
+  - Health checks and self-healing
+  - Backup and disaster recovery
+  - Loose coupling with queues
+
+patterns:
+  high_availability: |
+    # Multi-AZ RDS
+    - Primary in us-east-1a
+    - Standby in us-east-1b
+    - Read replicas in us-east-1c
+
+  auto_scaling: |
+    # Target tracking scaling
+    - Metric: CPUUtilization
+    - Target: 70%
+    - Min: 2, Max: 10
+```
+
+### 4. Performance Efficiency
+
+```yaml
+principles:
+  - Democratize advanced technologies
+  - Go global in minutes
+  - Use serverless architectures
+  - Experiment more often
+  - Consider mechanical sympathy
+
+compute:
+  - Right-size instances
+  - Use Spot for fault-tolerant workloads
+  - Consider Graviton (ARM) processors
+  - Containerize with ECS/EKS
+
+storage:
+  - Use appropriate storage class
+  - S3 Intelligent-Tiering for variable access
+  - EBS volume types based on IOPS needs
+
+database:
+  - Aurora for MySQL/PostgreSQL
+  - DynamoDB for key-value/document
+  - ElastiCache for caching
+```
+
+### 5. Cost Optimization
+
+```yaml
+principles:
+  - Implement cloud financial management
+  - Adopt consumption model
+  - Measure overall efficiency
+  - Stop spending on undifferentiated heavy lifting
+  - Analyze and attribute expenditure
+
+practices:
+  - Use Reserved Instances/Savings Plans
+  - Right-size resources
+  - Delete unused resources
+  - Use Spot Instances
+  - Implement auto scaling
+
+tools:
+  - AWS Cost Explorer
+  - AWS Budgets
+  - AWS Trusted Advisor
+  - Cost Allocation Tags
+```
+
+### 6. Sustainability
+
+```yaml
+principles:
+  - Understand your impact
+  - Establish sustainability goals
+  - Maximize utilization
+  - Anticipate and adopt more efficient offerings
+  - Use managed services
+  - Reduce downstream impact
+
+practices:
+  - Use efficient instance types (Graviton)
+  - Optimize storage lifecycle
+  - Use serverless where possible
+  - Select regions with lower carbon intensity
+```
+
+## Common Patterns
+
+### VPC Design
+
+```yaml
+pattern: |
+  VPC (10.0.0.0/16)
+  ├── Public Subnets
+  │   ├── us-east-1a: 10.0.1.0/24
+  │   ├── us-east-1b: 10.0.2.0/24
+  │   └── us-east-1c: 10.0.3.0/24
+  ├── Private Subnets (App)
+  │   ├── us-east-1a: 10.0.11.0/24
+  │   ├── us-east-1b: 10.0.12.0/24
+  │   └── us-east-1c: 10.0.13.0/24
+  └── Private Subnets (Data)
+      ├── us-east-1a: 10.0.21.0/24
+      ├── us-east-1b: 10.0.22.0/24
+      └── us-east-1c: 10.0.23.0/24
+
+components:
+  - Internet Gateway (public access)
+  - NAT Gateway (private outbound)
+  - VPC Endpoints (AWS services)
+  - Network ACLs (subnet level)
+  - Security Groups (instance level)
+```
+
+### Three-Tier Architecture
+
+```yaml
+pattern: |
+  [Internet]
+      │
+  [CloudFront]
+      │
+  [ALB] ← Public Subnet
+      │
+  [ECS/EC2] ← Private Subnet (App)
+      │
+  [RDS Multi-AZ] ← Private Subnet (Data)
+
+components:
+  web_tier:
+    - CloudFront for CDN
+    - WAF for protection
+    - ALB for load balancing
+
+  app_tier:
+    - ECS Fargate or EC2
+    - Auto Scaling
+    - ElastiCache
+
+  data_tier:
+    - RDS Multi-AZ
+    - Read Replicas
+    - Automated backups
+```
+
+### Serverless Pattern
+
+```yaml
+pattern: |
+  [API Gateway]
+      │
+  [Lambda] → [DynamoDB]
+      │
+  [SQS] → [Lambda] → [S3]
+
+components:
+  - API Gateway for REST/HTTP APIs
+  - Lambda for compute
+  - DynamoDB for NoSQL
+  - SQS for decoupling
+  - S3 for storage
+  - Step Functions for orchestration
+```
+
+### CI/CD Pipeline
+
+```yaml
+pattern: |
+  [CodeCommit/GitHub]
+      │
+  [CodePipeline]
+      │
+  ├── [CodeBuild] - Build & Test
+  │
+  ├── [ECR] - Container Registry
+  │
+  └── [CodeDeploy/ECS] - Deploy
+
+practices:
+  - Blue/Green deployments
+  - Canary releases
+  - Automated rollback
+  - Infrastructure as Code
+```
+
+## Application
+
+When designing AWS architecture:
+
+1. **Always** follow least privilege for IAM
+2. **Always** use Multi-AZ for production
+3. **Always** encrypt data at rest and in transit
+4. **Prefer** managed services over self-managed
+5. **Implement** monitoring and alerting
+6. **Use** IaC for all infrastructure
+7. **Design** for failure
+8. **Optimize** costs continuously

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

@@ -0,0 +1,27 @@
+# AWS Best Practices Skill
+
+metadata:
+  name: aws-best-practices
+  category: infrastructure
+  description: AWS patterns from Well-Architected Framework
+
+source:
+  type: internal
+  reference:
+    - https://docs.aws.amazon.com/wellarchitected/latest/framework/welcome.html
+    - https://docs.aws.amazon.com/
+    - https://aws.amazon.com/architecture/
+
+provides:
+  - Well-Architected Framework pillars
+  - Security best practices
+  - Reliability patterns
+  - Performance optimization
+  - Cost optimization
+  - VPC design patterns
+  - Three-tier architecture
+  - Serverless patterns
+  - CI/CD pipelines
+
+used_by:
+  - aws-expert