aigroup-workflow 2.2.1 → 2.2.2

package/skills/backend/architecture-designer/references/architecture-patterns.md

@@ -1,111 +1,111 @@
-# Architecture Patterns
-
-## Pattern Comparison
-
-| Pattern | Best For | Team Size | Trade-offs |
-|---------|----------|-----------|------------|
-| **Monolith** | Simple domain, small team | 1-10 | Simple deploy; hard to scale parts |
-| **Modular Monolith** | Growing complexity | 5-20 | Module boundaries; still single deploy |
-| **Microservices** | Complex domain, large org | 20+ | Independent scale; operational complexity |
-| **Serverless** | Variable load, event-driven | Any | Auto-scale; cold starts, vendor lock |
-| **Event-Driven** | Async processing | 10+ | Loose coupling; debugging complexity |
-
-## Monolith
-
-```
-┌─────────────────────────────────────┐
-│            Application              │
-│  ┌─────┐  ┌─────┐  ┌─────┐         │
-│  │Users│  │Orders│ │Products│       │
-│  └─────┘  └─────┘  └─────┘         │
-│  └──────────┬──────────────┘        │
-│          Database                    │
-└─────────────────────────────────────┘
-```
-
-**When to Use**:
-- Starting a new project
-- Small team (< 10 developers)
-- Simple domain
-- Rapid iteration needed
-
-**Pros**: Simple deployment, easy debugging, no network latency
-**Cons**: Hard to scale independently, technology locked, deployment risk
-
-## Microservices
-
-```
-┌──────────┐  ┌──────────┐  ┌──────────┐
-│  Users   │  │  Orders  │  │ Products │
-│ Service  │  │ Service  │  │ Service  │
-└────┬─────┘  └────┬─────┘  └────┬─────┘
-     │             │             │
-┌────▼────┐  ┌────▼────┐  ┌────▼────┐
-│ User DB │  │Order DB │  │ Prod DB │
-└─────────┘  └─────────┘  └─────────┘
-```
-
-**When to Use**:
-- Large team (20+ developers)
-- Complex domain with clear boundaries
-- Different scaling requirements per service
-- Polyglot technology needs
-
-**Pros**: Independent scaling, team autonomy, fault isolation
-**Cons**: Distributed system complexity, eventual consistency, operational overhead
-
-## Event-Driven
-
-```
-┌──────────┐     ┌─────────────┐     ┌──────────┐
-│ Producer │────▶│ Message Bus │────▶│ Consumer │
-└──────────┘     │  (Kafka)    │     └──────────┘
-                 └─────────────┘
-                       │
-                       ▼
-                 ┌──────────┐
-                 │ Consumer │
-                 └──────────┘
-```
-
-**When to Use**:
-- Async processing required
-- Loose coupling between services
-- Event sourcing needs
-- High throughput messaging
-
-**Pros**: Decoupled services, scalable, audit trail
-**Cons**: Eventual consistency, debugging complexity, message ordering
-
-## CQRS (Command Query Responsibility Segregation)
-
-```
-┌─────────┐         ┌─────────────┐
-│ Commands│────────▶│ Write Model │──┐
-└─────────┘         └─────────────┘  │
-                                     ▼
-                              ┌──────────┐
-                              │  Events  │
-                              └──────────┘
-                                     │
-┌─────────┐         ┌─────────────┐  │
-│ Queries │◀────────│ Read Model  │◀─┘
-└─────────┘         └─────────────┘
-```
-
-**When to Use**:
-- Read/write ratio heavily skewed
-- Complex read queries
-- Event sourcing architecture
-- Different optimization needs
-
-## Quick Reference
-
-| Requirement | Recommended Pattern |
-|-------------|---------------------|
-| Simple CRUD app | Monolith |
-| Growing startup | Modular Monolith |
-| Enterprise scale | Microservices |
-| Variable load | Serverless |
-| Async processing | Event-Driven |
-| Read-heavy | CQRS |
+# Architecture Patterns
+
+## Pattern Comparison
+
+| Pattern | Best For | Team Size | Trade-offs |
+|---------|----------|-----------|------------|
+| **Monolith** | Simple domain, small team | 1-10 | Simple deploy; hard to scale parts |
+| **Modular Monolith** | Growing complexity | 5-20 | Module boundaries; still single deploy |
+| **Microservices** | Complex domain, large org | 20+ | Independent scale; operational complexity |
+| **Serverless** | Variable load, event-driven | Any | Auto-scale; cold starts, vendor lock |
+| **Event-Driven** | Async processing | 10+ | Loose coupling; debugging complexity |
+
+## Monolith
+
+```
+┌─────────────────────────────────────┐
+│            Application              │
+│  ┌─────┐  ┌─────┐  ┌─────┐         │
+│  │Users│  │Orders│ │Products│       │
+│  └─────┘  └─────┘  └─────┘         │
+│  └──────────┬──────────────┘        │
+│          Database                    │
+└─────────────────────────────────────┘
+```
+
+**When to Use**:
+- Starting a new project
+- Small team (< 10 developers)
+- Simple domain
+- Rapid iteration needed
+
+**Pros**: Simple deployment, easy debugging, no network latency
+**Cons**: Hard to scale independently, technology locked, deployment risk
+
+## Microservices
+
+```
+┌──────────┐  ┌──────────┐  ┌──────────┐
+│  Users   │  │  Orders  │  │ Products │
+│ Service  │  │ Service  │  │ Service  │
+└────┬─────┘  └────┬─────┘  └────┬─────┘
+     │             │             │
+┌────▼────┐  ┌────▼────┐  ┌────▼────┐
+│ User DB │  │Order DB │  │ Prod DB │
+└─────────┘  └─────────┘  └─────────┘
+```
+
+**When to Use**:
+- Large team (20+ developers)
+- Complex domain with clear boundaries
+- Different scaling requirements per service
+- Polyglot technology needs
+
+**Pros**: Independent scaling, team autonomy, fault isolation
+**Cons**: Distributed system complexity, eventual consistency, operational overhead
+
+## Event-Driven
+
+```
+┌──────────┐     ┌─────────────┐     ┌──────────┐
+│ Producer │────▶│ Message Bus │────▶│ Consumer │
+└──────────┘     │  (Kafka)    │     └──────────┘
+                 └─────────────┘
+                       │
+                       ▼
+                 ┌──────────┐
+                 │ Consumer │
+                 └──────────┘
+```
+
+**When to Use**:
+- Async processing required
+- Loose coupling between services
+- Event sourcing needs
+- High throughput messaging
+
+**Pros**: Decoupled services, scalable, audit trail
+**Cons**: Eventual consistency, debugging complexity, message ordering
+
+## CQRS (Command Query Responsibility Segregation)
+
+```
+┌─────────┐         ┌─────────────┐
+│ Commands│────────▶│ Write Model │──┐
+└─────────┘         └─────────────┘  │
+                                     ▼
+                              ┌──────────┐
+                              │  Events  │
+                              └──────────┘
+                                     │
+┌─────────┐         ┌─────────────┐  │
+│ Queries │◀────────│ Read Model  │◀─┘
+└─────────┘         └─────────────┘
+```
+
+**When to Use**:
+- Read/write ratio heavily skewed
+- Complex read queries
+- Event sourcing architecture
+- Different optimization needs
+
+## Quick Reference
+
+| Requirement | Recommended Pattern |
+|-------------|---------------------|
+| Simple CRUD app | Monolith |
+| Growing startup | Modular Monolith |
+| Enterprise scale | Microservices |
+| Variable load | Serverless |
+| Async processing | Event-Driven |
+| Read-heavy | CQRS |

package/skills/backend/architecture-designer/references/database-selection.md

@@ -1,102 +1,102 @@
-# Database Selection
-
-## Database Types
-
-| Type | Examples | Best For |
-|------|----------|----------|
-| **Relational** | PostgreSQL, MySQL | Transactions, complex queries, relationships |
-| **Document** | MongoDB, Firestore | Flexible schemas, rapid iteration |
-| **Key-Value** | Redis, DynamoDB | Caching, sessions, high throughput |
-| **Time-Series** | TimescaleDB, InfluxDB | Metrics, IoT, analytics |
-| **Graph** | Neo4j, Neptune | Relationships, social networks |
-| **Search** | Elasticsearch, Meilisearch | Full-text search, logs |
-
-## Relational (PostgreSQL, MySQL)
-
-```
-Best For:
-- Financial transactions (ACID compliance)
-- Complex queries with joins
-- Data integrity requirements
-- Structured, predictable schemas
-
-When to Avoid:
-- Highly variable schemas
-- Massive horizontal scaling needs
-- Simple key-value access patterns
-```
-
-| Feature | PostgreSQL | MySQL |
-|---------|------------|-------|
-| JSON support | Excellent (JSONB) | Good (JSON) |
-| Full-text search | Built-in | Basic |
-| Extensions | Rich ecosystem | Limited |
-| Replication | Streaming, logical | Statement, row-based |
-
-## Document (MongoDB, Firestore)
-
-```
-Best For:
-- Flexible, evolving schemas
-- Hierarchical data (nested documents)
-- Rapid prototyping
-- Content management
-
-When to Avoid:
-- Complex transactions across documents
-- Heavy relational queries
-- Strict schema requirements
-```
-
-## Key-Value (Redis, DynamoDB)
-
-```
-Best For:
-- Session storage
-- Caching layer
-- Real-time leaderboards
-- Rate limiting counters
-
-When to Avoid:
-- Complex queries
-- Relational data
-- Large value sizes (>1MB)
-```
-
-## Time-Series (TimescaleDB, InfluxDB)
-
-```
-Best For:
-- Metrics and monitoring
-- IoT sensor data
-- Financial tick data
-- Event logging with timestamps
-
-When to Avoid:
-- Frequent updates to existing records
-- Complex relational queries
-- Non-time-based access patterns
-```
-
-## Decision Matrix
-
-| Requirement | Recommended |
-|-------------|-------------|
-| ACID transactions | PostgreSQL, MySQL |
-| Flexible schema | MongoDB, Firestore |
-| High-speed caching | Redis |
-| Time-series data | TimescaleDB, InfluxDB |
-| Social relationships | Neo4j |
-| Full-text search | Elasticsearch |
-| Serverless scale | DynamoDB, Firestore |
-
-## Quick Reference
-
-| Question | If Yes → |
-|----------|----------|
-| Need ACID transactions? | Relational (PostgreSQL) |
-| Schema changes frequently? | Document (MongoDB) |
-| Sub-millisecond reads? | Key-Value (Redis) |
-| Time-based queries? | Time-Series |
-| Traversing relationships? | Graph (Neo4j) |
-| Full-text search primary? | Elasticsearch |
+# Database Selection
+
+## Database Types
+
+| Type | Examples | Best For |
+|------|----------|----------|
+| **Relational** | PostgreSQL, MySQL | Transactions, complex queries, relationships |
+| **Document** | MongoDB, Firestore | Flexible schemas, rapid iteration |
+| **Key-Value** | Redis, DynamoDB | Caching, sessions, high throughput |
+| **Time-Series** | TimescaleDB, InfluxDB | Metrics, IoT, analytics |
+| **Graph** | Neo4j, Neptune | Relationships, social networks |
+| **Search** | Elasticsearch, Meilisearch | Full-text search, logs |
+
+## Relational (PostgreSQL, MySQL)
+
+```
+Best For:
+- Financial transactions (ACID compliance)
+- Complex queries with joins
+- Data integrity requirements
+- Structured, predictable schemas
+
+When to Avoid:
+- Highly variable schemas
+- Massive horizontal scaling needs
+- Simple key-value access patterns
+```
+
+| Feature | PostgreSQL | MySQL |
+|---------|------------|-------|
+| JSON support | Excellent (JSONB) | Good (JSON) |
+| Full-text search | Built-in | Basic |
+| Extensions | Rich ecosystem | Limited |
+| Replication | Streaming, logical | Statement, row-based |
+
+## Document (MongoDB, Firestore)
+
+```
+Best For:
+- Flexible, evolving schemas
+- Hierarchical data (nested documents)
+- Rapid prototyping
+- Content management
+
+When to Avoid:
+- Complex transactions across documents
+- Heavy relational queries
+- Strict schema requirements
+```
+
+## Key-Value (Redis, DynamoDB)
+
+```
+Best For:
+- Session storage
+- Caching layer
+- Real-time leaderboards
+- Rate limiting counters
+
+When to Avoid:
+- Complex queries
+- Relational data
+- Large value sizes (>1MB)
+```
+
+## Time-Series (TimescaleDB, InfluxDB)
+
+```
+Best For:
+- Metrics and monitoring
+- IoT sensor data
+- Financial tick data
+- Event logging with timestamps
+
+When to Avoid:
+- Frequent updates to existing records
+- Complex relational queries
+- Non-time-based access patterns
+```
+
+## Decision Matrix
+
+| Requirement | Recommended |
+|-------------|-------------|
+| ACID transactions | PostgreSQL, MySQL |
+| Flexible schema | MongoDB, Firestore |
+| High-speed caching | Redis |
+| Time-series data | TimescaleDB, InfluxDB |
+| Social relationships | Neo4j |
+| Full-text search | Elasticsearch |
+| Serverless scale | DynamoDB, Firestore |
+
+## Quick Reference
+
+| Question | If Yes → |
+|----------|----------|
+| Need ACID transactions? | Relational (PostgreSQL) |
+| Schema changes frequently? | Document (MongoDB) |
+| Sub-millisecond reads? | Key-Value (Redis) |
+| Time-based queries? | Time-Series |
+| Traversing relationships? | Graph (Neo4j) |
+| Full-text search primary? | Elasticsearch |

package/skills/backend/architecture-designer/references/nfr-checklist.md

@@ -1,112 +1,112 @@
-# Non-Functional Requirements Checklist
-
-## NFR Categories
-
-### Scalability
-
-| Question | Common Targets |
-|----------|----------------|
-| Expected concurrent users? | 100 / 1K / 10K / 100K |
-| Requests per second? | 10 / 100 / 1000 / 10000 |
-| Data volume? | GB / TB / PB |
-| Growth rate? | 10% / 50% / 100% per year |
-| Peak vs average load? | 2x / 5x / 10x |
-
-### Performance
-
-| Question | Common Targets |
-|----------|----------------|
-| API response time? | < 100ms / 200ms / 500ms p95 |
-| Page load time? | < 1s / 2s / 3s |
-| Database query time? | < 10ms / 50ms / 100ms |
-| Batch processing throughput? | 1K / 10K / 100K records/hour |
-
-### Availability
-
-| Target | Downtime/Year | Use Case |
-|--------|---------------|----------|
-| 99% | 3.65 days | Internal tools |
-| 99.9% | 8.76 hours | Business apps |
-| 99.95% | 4.38 hours | E-commerce |
-| 99.99% | 52.6 minutes | Financial systems |
-| 99.999% | 5.26 minutes | Life-critical |
-
-### Security
-
-| Question | Considerations |
-|----------|----------------|
-| Authentication required? | JWT, OAuth, SAML, MFA |
-| Authorization model? | RBAC, ABAC, ACL |
-| Data sensitivity? | Public, internal, confidential, PII |
-| Compliance requirements? | GDPR, HIPAA, PCI DSS, SOC 2 |
-| Encryption needs? | At rest, in transit, end-to-end |
-
-### Reliability
-
-| Question | Considerations |
-|----------|----------------|
-| Acceptable data loss? | RPO: 0 / 1hr / 24hr |
-| Recovery time target? | RTO: 1hr / 4hr / 24hr |
-| Backup frequency? | Real-time / hourly / daily |
-| Disaster recovery? | Single region / multi-region |
-
-### Maintainability
-
-| Question | Considerations |
-|----------|----------------|
-| Deployment frequency? | Daily / weekly / monthly |
-| Deployment strategy? | Blue-green, canary, rolling |
-| Monitoring requirements? | Logs, metrics, traces, alerts |
-| On-call requirements? | 24/7, business hours |
-
-### Cost
-
-| Question | Considerations |
-|----------|----------------|
-| Infrastructure budget? | $/month, $/user, $/request |
-| Operational budget? | FTE for maintenance |
-| Cost optimization? | Reserved instances, spot instances |
-| Cost alerts? | Thresholds for notification |
-
-## Template
-
-```markdown
-## Non-Functional Requirements
-
-### Performance
-- API response time: < 200ms p95
-- Page load time: < 2s
-- Database query time: < 50ms
-
-### Scalability
-- Concurrent users: 10,000
-- Requests per second: 1,000
-- Data volume: 1TB
-
-### Availability
-- Target: 99.9% (8.76 hours/year downtime)
-- RPO: 1 hour
-- RTO: 4 hours
-
-### Security
-- Authentication: JWT with refresh tokens
-- Authorization: Role-based (admin, user, guest)
-- Compliance: GDPR, SOC 2
-
-### Observability
-- Logging: Structured JSON to ELK
-- Metrics: Prometheus + Grafana
-- Tracing: OpenTelemetry
-- Alerts: PagerDuty integration
-```
-
-## Quick Reference
-
-| Category | Key Metric |
-|----------|------------|
-| Performance | Response time (p95) |
-| Scalability | Concurrent users, RPS |
-| Availability | Uptime percentage |
-| Reliability | RPO, RTO |
-| Security | Compliance requirements |
-| Cost | $/month budget |
+# Non-Functional Requirements Checklist
+
+## NFR Categories
+
+### Scalability
+
+| Question | Common Targets |
+|----------|----------------|
+| Expected concurrent users? | 100 / 1K / 10K / 100K |
+| Requests per second? | 10 / 100 / 1000 / 10000 |
+| Data volume? | GB / TB / PB |
+| Growth rate? | 10% / 50% / 100% per year |
+| Peak vs average load? | 2x / 5x / 10x |
+
+### Performance
+
+| Question | Common Targets |
+|----------|----------------|
+| API response time? | < 100ms / 200ms / 500ms p95 |
+| Page load time? | < 1s / 2s / 3s |
+| Database query time? | < 10ms / 50ms / 100ms |
+| Batch processing throughput? | 1K / 10K / 100K records/hour |
+
+### Availability
+
+| Target | Downtime/Year | Use Case |
+|--------|---------------|----------|
+| 99% | 3.65 days | Internal tools |
+| 99.9% | 8.76 hours | Business apps |
+| 99.95% | 4.38 hours | E-commerce |
+| 99.99% | 52.6 minutes | Financial systems |
+| 99.999% | 5.26 minutes | Life-critical |
+
+### Security
+
+| Question | Considerations |
+|----------|----------------|
+| Authentication required? | JWT, OAuth, SAML, MFA |
+| Authorization model? | RBAC, ABAC, ACL |
+| Data sensitivity? | Public, internal, confidential, PII |
+| Compliance requirements? | GDPR, HIPAA, PCI DSS, SOC 2 |
+| Encryption needs? | At rest, in transit, end-to-end |
+
+### Reliability
+
+| Question | Considerations |
+|----------|----------------|
+| Acceptable data loss? | RPO: 0 / 1hr / 24hr |
+| Recovery time target? | RTO: 1hr / 4hr / 24hr |
+| Backup frequency? | Real-time / hourly / daily |
+| Disaster recovery? | Single region / multi-region |
+
+### Maintainability
+
+| Question | Considerations |
+|----------|----------------|
+| Deployment frequency? | Daily / weekly / monthly |
+| Deployment strategy? | Blue-green, canary, rolling |
+| Monitoring requirements? | Logs, metrics, traces, alerts |
+| On-call requirements? | 24/7, business hours |
+
+### Cost
+
+| Question | Considerations |
+|----------|----------------|
+| Infrastructure budget? | $/month, $/user, $/request |
+| Operational budget? | FTE for maintenance |
+| Cost optimization? | Reserved instances, spot instances |
+| Cost alerts? | Thresholds for notification |
+
+## Template
+
+```markdown
+## Non-Functional Requirements
+
+### Performance
+- API response time: < 200ms p95
+- Page load time: < 2s
+- Database query time: < 50ms
+
+### Scalability
+- Concurrent users: 10,000
+- Requests per second: 1,000
+- Data volume: 1TB
+
+### Availability
+- Target: 99.9% (8.76 hours/year downtime)
+- RPO: 1 hour
+- RTO: 4 hours
+
+### Security
+- Authentication: JWT with refresh tokens
+- Authorization: Role-based (admin, user, guest)
+- Compliance: GDPR, SOC 2
+
+### Observability
+- Logging: Structured JSON to ELK
+- Metrics: Prometheus + Grafana
+- Tracing: OpenTelemetry
+- Alerts: PagerDuty integration
+```
+
+## Quick Reference
+
+| Category | Key Metric |
+|----------|------------|
+| Performance | Response time (p95) |
+| Scalability | Concurrent users, RPS |
+| Availability | Uptime percentage |
+| Reliability | RPO, RTO |
+| Security | Compliance requirements |
+| Cost | $/month budget |