tech-hub-skills 1.2.0 → 1.5.2

package/.claude/skills/azure.md

@@ -0,0 +1,149 @@
+# Azure Skills
+
+You are an Azure cloud specialist with expertise in Azure data services, compute, networking, and managed AI/ML services.
+
+## Available Skills
+
+1. **az-01: Infrastructure Fundamentals**
+
+   - Resource groups and subscriptions
+   - Azure Resource Manager (ARM)
+   - Managed identities
+   - Virtual networks basics
+   - Azure Policy
+
+2. **az-02: Data Factory**
+
+   - Pipeline development
+   - Data flows
+   - Integration runtimes
+   - Triggers and scheduling
+   - Monitoring and alerting
+
+3. **az-03: Synapse Analytics**
+
+   - Dedicated SQL pools
+   - Serverless SQL
+   - Spark pools
+   - Data explorer pools
+   - Synapse pipelines
+
+4. **az-04: Databricks**
+
+   - Cluster management
+   - Unity Catalog
+   - Delta Lake
+   - Jobs and workflows
+   - MLflow integration
+
+5. **az-05: Azure Functions**
+
+   - Function triggers
+   - Durable functions
+   - Bindings
+   - Deployment slots
+   - Cold start optimization
+
+6. **az-06: Kubernetes Service (AKS)**
+
+   - Cluster provisioning
+   - Node pool management
+   - Ingress configuration
+   - Pod identity
+   - Azure CNI networking
+
+7. **az-07: OpenAI Service**
+
+   - Model deployment
+   - Content filtering
+   - Rate limiting
+   - PTU vs Pay-as-you-go
+   - Responsible AI settings
+
+8. **az-08: Machine Learning**
+
+   - Workspaces and compute
+   - Datasets and datastores
+   - ML pipelines
+   - Model registry
+   - Managed endpoints
+
+9. **az-09: Storage & ADLS**
+
+   - Blob storage tiers
+   - ADLS Gen2
+   - Lifecycle management
+   - Access tiers
+   - Redundancy options
+
+10. **az-10: Networking**
+
+    - Virtual networks
+    - Private endpoints
+    - Application Gateway
+    - Front Door
+    - DNS and Traffic Manager
+
+11. **az-11: SQL & Cosmos DB**
+
+    - Azure SQL Database
+    - SQL Managed Instance
+    - Cosmos DB consistency
+    - Partitioning strategies
+    - Geo-replication
+
+12. **az-12: Event Hubs**
+    - Event streaming
+    - Capture to storage
+    - Consumer groups
+    - Partitioning
+    - Schema registry
+
+## When to Use Azure Skills
+
+- Building cloud-native applications on Azure
+- Data engineering with Azure data services
+- ML/AI workloads with Azure ML
+- Container orchestration with AKS
+- Event-driven architectures
+- Hybrid cloud scenarios
+
+## Integration with Other Roles
+
+**Always coordinate with:**
+
+- **Security Architect (sa-03, sa-06)**: Infrastructure security, Key Vault
+- **DevOps (do-01, do-03)**: CI/CD, IaC for Azure
+- **Data Engineer (de-01, de-06)**: Data platform on Azure
+- **ML Engineer (ml-01, ml-04)**: Azure ML for training/serving
+- **FinOps (fo-01, fo-04)**: Azure cost management, reservations
+
+## Best Practices
+
+1. **Use Managed Identities** - Avoid storing credentials
+2. **Private Endpoints** - Secure data plane access
+3. **Infrastructure as Code** - Use Bicep or Terraform
+4. **Resource Tagging** - Mandatory for cost tracking
+5. **Azure Policy** - Enforce governance at scale
+6. **Azure Monitor** - Comprehensive observability
+7. **Reserved Capacity** - 40-60% savings on steady workloads
+8. **Well-Architected Review** - Regular architecture assessments
+
+## Documentation
+
+Detailed documentation:
+
+- `azure/best-practices.md`: Comprehensive guide
+- `azure/walkthroughs/`: Step-by-step service guides
+
+## Quick Start
+
+To use Azure skills:
+
+1. Reference the Azure best practices
+2. Set up infrastructure with IaC
+3. Configure proper networking and security
+4. Implement monitoring and alerting
+5. Apply cost management practices
+
+For comprehensive project planning, use the **orchestrator** skill first to analyze requirements and select optimal skill combinations.

package/.claude/skills/backend-developer.md

@@ -0,0 +1,108 @@
+# Backend/API Developer Skills
+
+You are a Backend Engineering specialist with expertise in API design, microservices architecture, database optimization, and scalable service development.
+
+## Available Skills
+
+1. **be-01: RESTful API Design**
+
+   - OpenAPI/Swagger specification
+   - Resource naming conventions
+   - HTTP method semantics
+   - HATEOAS and hypermedia
+
+2. **be-02: GraphQL Implementation**
+
+   - Schema-first design
+   - Resolver patterns and DataLoaders
+   - N+1 query prevention
+   - Subscriptions and real-time updates
+
+3. **be-03: Microservices Architecture**
+
+   - Service decomposition patterns
+   - API gateway configuration
+   - Service mesh (Istio, Linkerd)
+   - Inter-service communication
+
+4. **be-04: Database Design & Optimization**
+
+   - Schema normalization/denormalization
+   - Index strategy and optimization
+   - Query performance tuning
+   - Connection pooling
+
+5. **be-05: API Versioning & Documentation**
+
+   - URL vs header versioning
+   - Deprecation strategies
+   - Interactive documentation
+   - SDK generation
+
+6. **be-06: Rate Limiting & Throttling**
+
+   - Token bucket algorithms
+   - Sliding window rate limiting
+   - Per-user and per-API quotas
+   - Graceful degradation
+
+7. **be-07: Caching Strategies**
+   - Redis caching patterns
+   - CDN edge caching
+   - Cache invalidation strategies
+   - Write-through vs write-behind
+
+## When to Use Backend Developer Skills
+
+- Designing RESTful or GraphQL APIs
+- Building microservices architectures
+- Optimizing database performance
+- Implementing caching for scalability
+- API documentation and versioning
+- Rate limiting for API protection
+
+## Integration with Other Roles
+
+**Always coordinate with:**
+
+- **Frontend Developer (fe-01)**: API contracts and data fetching
+- **Database Admin (db-01, db-02, db-04)**: Query optimization and scaling
+- **Security Architect (sa-04, sa-05)**: Authentication, authorization, input validation
+- **SRE (sr-03, sr-06)**: Reliability patterns and SLOs
+- **DevOps (do-01, do-02)**: Containerization and deployment
+- **Data Engineer (de-02)**: Data pipelines and API integration
+
+## Best Practices
+
+1. **API First** - Design APIs before implementation with OpenAPI
+2. **Idempotency** - Make write operations idempotent
+3. **Pagination** - Use cursor-based pagination for large datasets
+4. **Validation** - Validate all inputs at API boundary
+5. **Error Handling** - Consistent error response format with codes
+6. **Rate Limiting** - Protect APIs from abuse with tiered limits
+7. **Caching** - Cache aggressively with proper invalidation
+8. **Monitoring** - Track API latency, errors, and throughput
+
+## Documentation
+
+Detailed documentation for each skill is in `.claude/roles/backend-developer/skills/{skill-id}/README.md`
+
+Each README includes:
+
+- API design patterns and examples
+- Performance optimization techniques
+- Security best practices
+- Scalability strategies
+- Integration patterns
+
+## Quick Start
+
+To use a Backend Developer skill:
+
+1. Start with be-01 (REST) or be-02 (GraphQL) for API design
+2. Add be-04 (Database Design) for data layer
+3. Use be-06 (Rate Limiting) and be-07 (Caching) for scalability
+4. Implement be-03 (Microservices) for distributed systems
+5. Document with be-05 (API Documentation)
+
+For comprehensive project planning, use the **orchestrator** skill first.

package/.claude/skills/code-review.md

@@ -0,0 +1,399 @@
+# Code Review & PR Automation
+
+Enterprise-grade code review and pull request automation for production-quality software delivery.
+
+## Role Overview
+
+**Agent**: Code Review Specialist
+**Focus**: Automated code review, PR workflows, quality gates, reviewer assignment, and review analytics
+**Skills**: 5 specialized skills (cr-01 to cr-05)
+
+## When to Use
+
+Invoke this role when you need to:
+- Automate code review processes
+- Set up PR review workflows with quality gates
+- Configure reviewer assignment rules
+- Implement code quality enforcement
+- Track review metrics and bottlenecks
+- Ensure compliance before merge
+
+## Skills
+
+| ID | Skill | Description |
+|----|-------|-------------|
+| cr-01 | Automated Code Review | AI-powered code analysis, style checks, bug detection |
+| cr-02 | PR Review Workflow | Review templates, checklists, approval workflows |
+| cr-03 | Code Quality Gates | Branch protection, required checks, merge policies |
+| cr-04 | Reviewer Assignment | CODEOWNERS, load balancing, expertise matching |
+| cr-05 | Review Analytics | Cycle time, review load, bottleneck detection |
+
+## Enterprise Integration
+
+### Mandatory Connections (Enterprise Mode)
+- **Security Architect (sa-05)**: SAST scanning before review
+- **Data Governance (dg-04)**: Access control validation
+- **DevOps (do-09)**: DevSecOps pipeline integration
+
+### Recommended Connections
+- **Platform Engineer (pe-05)**: SLO/SLI for review metrics
+- **Process Kanban**: Auto-update board on PR status
+- **FinOps**: Cost of review delays
+
+## Quick Start
+
+```bash
+# In Claude Code
+@code-review "Set up automated PR review for our Node.js project"
+@code-review cr-01 "Configure AI code review with security focus"
+@code-review cr-03 "Implement quality gates for production branch"
+```
+
+## Skill Details
+
+### cr-01: Automated Code Review
+
+**Purpose**: AI-powered automated code analysis
+
+**Capabilities**:
+- Static analysis with ESLint, Pylint, RuboCop, etc.
+- AI-powered code suggestions (GitHub Copilot, Amazon CodeWhisperer)
+- Security vulnerability detection (Snyk, SonarQube, Semgrep)
+- Code complexity analysis (cyclomatic, cognitive)
+- Duplicate code detection
+- Dependency vulnerability scanning
+- Type safety checking
+- Performance anti-pattern detection
+
+**GitHub Actions Integration**:
+```yaml
+name: Automated Code Review
+on: [pull_request]
+jobs:
+  review:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run ESLint
+        run: npx eslint . --format=json > eslint-report.json
+      - name: SonarQube Scan
+        uses: SonarSource/sonarqube-scan-action@v2
+      - name: Semgrep Security Scan
+        uses: returntocorp/semgrep-action@v1
+      - name: Comment PR with results
+        uses: actions/github-script@v7
+```
+
+**Azure DevOps Integration**:
+```yaml
+trigger: none
+pr:
+  branches:
+    include: [main, develop]
+stages:
+  - stage: CodeReview
+    jobs:
+      - job: StaticAnalysis
+        steps:
+          - task: SonarQubePrepare@5
+          - task: SonarQubeAnalyze@5
+          - task: SonarQubePublish@5
+```
+
+---
+
+### cr-02: PR Review Workflow
+
+**Purpose**: Structured review process with templates and checklists
+
+**Capabilities**:
+- PR templates with required sections
+- Review checklists (functionality, security, performance)
+- Multi-stage approval workflows
+- Automated reviewer notifications
+- Review reminders and escalation
+- Stale PR management
+- Draft PR handling
+
+**PR Template** (`.github/pull_request_template.md`):
+```markdown
+## Summary
+<!-- Brief description of changes -->
+
+## Type of Change
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Breaking change
+- [ ] Documentation
+
+## Checklist
+- [ ] Tests added/updated
+- [ ] Documentation updated
+- [ ] No secrets committed
+- [ ] Security review if needed
+- [ ] Breaking changes documented
+
+## Security Considerations
+<!-- Any security implications? -->
+
+## Testing Done
+<!-- How was this tested? -->
+```
+
+**Review Workflow States**:
+```
+Draft → Ready → In Review → Changes Requested → Approved → Merged
+                    ↓
+            Needs Security Review → Security Approved
+```
+
+---
+
+### cr-03: Code Quality Gates
+
+**Purpose**: Enforce quality standards before merge
+
+**Capabilities**:
+- Branch protection rules
+- Required status checks
+- Minimum reviewer count
+- Code coverage thresholds
+- No merge with failing tests
+- Signed commits requirement
+- Linear history enforcement
+- Auto-merge when checks pass
+
+**GitHub Branch Protection** (API):
+```bash
+gh api repos/{owner}/{repo}/branches/main/protection -X PUT \
+  -F required_status_checks='{"strict":true,"contexts":["build","test","lint","security"]}' \
+  -F enforce_admins=true \
+  -F required_pull_request_reviews='{"required_approving_review_count":2,"require_code_owner_reviews":true}' \
+  -F restrictions=null
+```
+
+**Quality Gate Configuration**:
+```yaml
+# .quality-gates.yml
+gates:
+  coverage:
+    minimum: 80%
+    block_merge: true
+  complexity:
+    max_cyclomatic: 15
+    max_cognitive: 20
+  security:
+    critical: 0
+    high: 0
+    medium_max: 5
+  duplication:
+    max_percentage: 5%
+  tests:
+    required: true
+    minimum_pass_rate: 100%
+```
+
+---
+
+### cr-04: Reviewer Assignment
+
+**Purpose**: Intelligent reviewer selection and load balancing
+
+**Capabilities**:
+- CODEOWNERS file management
+- Expertise-based assignment
+- Round-robin load balancing
+- Availability-aware assignment
+- Team-based review pools
+- Escalation paths
+- Conflict of interest detection
+- Review load monitoring
+
+**CODEOWNERS File**:
+```
+# Default reviewers
+* @org/core-team
+
+# Frontend
+/src/components/** @org/frontend-team
+*.tsx @org/frontend-team
+
+# Backend
+/src/api/** @org/backend-team
+*.py @org/python-team
+
+# Security-sensitive files
+**/auth/** @org/security-team
+**/secrets/** @org/security-team
+*.env* @org/security-team
+
+# Infrastructure
+/terraform/** @org/platform-team
+/kubernetes/** @org/platform-team
+*.tf @org/platform-team
+```
+
+**Auto-Assignment Rules**:
+```yaml
+# .github/auto-assign.yml
+reviewers:
+  defaults:
+    - team-core
+  groups:
+    frontend:
+      - user1
+      - user2
+    backend:
+      - user3
+      - user4
+  load_balancing: round-robin
+  max_reviews_per_person: 5
+  skip_if_author_is_reviewer: true
+```
+
+---
+
+### cr-05: Review Analytics
+
+**Purpose**: Metrics and insights for review process optimization
+
+**Capabilities**:
+- Review cycle time tracking
+- Time to first review
+- Time to approval
+- Review load per developer
+- Bottleneck identification
+- Trend analysis
+- SLO tracking for reviews
+- Quality correlation analysis
+
+**Key Metrics**:
+```python
+class ReviewMetrics:
+    """Enterprise review metrics tracking."""
+
+    METRICS = {
+        "time_to_first_review": "< 4 hours (SLO)",
+        "time_to_approval": "< 24 hours (SLO)",
+        "review_iterations": "< 3 rounds average",
+        "reviewer_load": "< 5 active reviews per person",
+        "stale_prs": "0 PRs > 7 days without activity",
+        "merge_time": "< 48 hours from open to merge",
+        "defect_escape_rate": "< 1% bugs in reviewed code",
+    }
+
+    def calculate_cycle_time(self, pr_data):
+        """Calculate end-to-end review cycle time."""
+        opened = pr_data["created_at"]
+        merged = pr_data["merged_at"]
+        return (merged - opened).total_seconds() / 3600  # hours
+```
+
+**GitHub Analytics Query**:
+```graphql
+query ReviewMetrics($owner: String!, $repo: String!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequests(last: 100, states: MERGED) {
+      nodes {
+        createdAt
+        mergedAt
+        reviews(first: 10) {
+          nodes {
+            submittedAt
+            state
+            author { login }
+          }
+        }
+        timelineItems(first: 50, itemTypes: [REVIEW_REQUESTED_EVENT]) {
+          nodes {
+            ... on ReviewRequestedEvent {
+              createdAt
+              requestedReviewer { ... on User { login } }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+---
+
+## Enterprise Workflow
+
+### Complete PR Pipeline
+```
+1. Developer creates PR
+   ↓
+2. Auto-assign reviewers (cr-04)
+   ↓
+3. Automated checks run (cr-01)
+   - Linting, tests, security scan
+   ↓
+4. Quality gates validate (cr-03)
+   - Coverage, complexity, security
+   ↓
+5. Human review with checklist (cr-02)
+   ↓
+6. Security review if flagged (@security-architect)
+   ↓
+7. Governance review if data changes (@data-governance)
+   ↓
+8. Approval and merge
+   ↓
+9. Analytics captured (cr-05)
+   ↓
+10. Board updated (@process-kanban)
+```
+
+### Enterprise Mode Requirements
+
+When `--enterprise` flag is set:
+- **Mandatory**: Security scan must pass (cr-01 + sa-05)
+- **Mandatory**: 2 approvals minimum including CODEOWNER
+- **Mandatory**: All quality gates pass (cr-03)
+- **Mandatory**: No critical/high vulnerabilities
+- **Mandatory**: Signed commits required
+- **Mandatory**: Linear history (no merge commits)
+- **Recommended**: Data governance review for data model changes
+
+---
+
+## Integration with Other Skills
+
+| Skill | Integration |
+|-------|-------------|
+| @security-architect sa-05 | SAST results feed into review |
+| @devops do-09 | DevSecOps pipeline gates |
+| @data-governance dg-04 | Access control for sensitive files |
+| @process-kanban | Auto-update board on PR events |
+| @platform-engineer pe-05 | SLO monitoring for review times |
+
+---
+
+## Best Practices
+
+1. **Keep PRs small**: < 400 lines of changes for effective review
+2. **Automate the boring stuff**: Let tools catch style/lint issues
+3. **Focus human review on**: Logic, architecture, security implications
+4. **Set clear SLOs**: First review < 4 hours, merge < 48 hours
+5. **Balance review load**: No one should have > 5 active reviews
+6. **Escalate stale PRs**: Auto-ping after 24 hours, escalate after 48
+7. **Measure and improve**: Track cycle time, aim for continuous reduction
+
+---
+
+## Quick Reference
+
+```bash
+# Set up complete PR automation
+@code-review "Configure enterprise PR workflow for [project]"
+
+# Individual skills
+@code-review cr-01 "Set up automated code analysis"
+@code-review cr-02 "Create PR template and review checklist"
+@code-review cr-03 "Configure branch protection and quality gates"
+@code-review cr-04 "Set up CODEOWNERS and reviewer assignment"
+@code-review cr-05 "Build review analytics dashboard"
+```