specweave 0.23.16 → 0.24.0

package/plugins/specweave-ado/commands/specweave-ado-import-projects.md

@@ -0,0 +1,331 @@
+---
+name: specweave-ado:import-projects
+description: Import additional Azure DevOps projects post-init with area path mapping, filtering, and dry-run preview
+---
+
+# Import Azure DevOps Projects Command
+
+You are an Azure DevOps project import expert. Help users add additional ADO projects to their SpecWeave workspace after initial setup.
+
+## Purpose
+
+This command allows users to import additional Azure DevOps projects **after** initial SpecWeave setup (`specweave init`), with area path mapping, filtering, and dry-run preview.
+
+**Use Cases**:
+- Adding new ADO projects to existing workspace
+- Importing projects from different organizations
+- Selective import with area path granularity
+- Multi-project organization (Backend, Frontend, Mobile, Infrastructure)
+
+## Command Syntax
+
+```bash
+# Basic import (interactive)
+/specweave-ado:import-projects
+
+# With area path granularity
+/specweave-ado:import-projects --granularity two-level
+
+# Dry-run (preview)
+/specweave-ado:import-projects --dry-run
+
+# Resume interrupted import
+/specweave-ado:import-projects --resume
+
+# Combined
+/specweave-ado:import-projects --granularity top-level --dry-run
+```
+
+## Your Task
+
+When the user runs this command:
+
+### Step 1: Validate Prerequisites
+```typescript
+import { readEnvFile, parseEnvFile } from '../../../src/utils/env-file.js';
+
+// 1. Check if ADO credentials exist
+const envContent = readEnvFile(process.cwd());
+const parsed = parseEnvFile(envContent);
+
+if (!parsed.AZURE_DEVOPS_PAT || !parsed.AZURE_DEVOPS_ORG) {
+  console.log('❌ Missing Azure DevOps credentials. Run `specweave init` first.');
+  return;
+}
+
+// 2. Get existing configuration
+const org = parsed.AZURE_DEVOPS_ORG;
+const existingProject = parsed.AZURE_DEVOPS_PROJECT;
+
+console.log(`\n📋 Organization: ${org}`);
+console.log(`   Current project: ${existingProject || 'None'}\n`);
+```
+
+### Step 2: Fetch Available Projects
+```typescript
+import { getProjectCount } from '../../../src/cli/helpers/project-count-fetcher.js';
+import { AsyncProjectLoader } from '../../../src/cli/helpers/async-project-loader.js';
+
+// Count check (< 1 second)
+const countResult = await getProjectCount({
+  provider: 'ado',
+  credentials: {
+    organization: org,
+    pat: parsed.AZURE_DEVOPS_PAT
+  }
+});
+
+console.log(`✓ Found ${countResult.accessible} accessible project(s)`);
+
+// Fetch all projects (with smart pagination)
+const loader = new AsyncProjectLoader(
+  {
+    organization: org,
+    pat: parsed.AZURE_DEVOPS_PAT
+  },
+  'ado',
+  {
+    batchSize: 50,
+    updateFrequency: 5,
+    showEta: true
+  }
+);
+
+const result = await loader.fetchAllProjects(countResult.accessible);
+const allProjects = result.projects;
+```
+
+### Step 3: Area Path Mapping (Multi-Project Organization)
+```typescript
+import { AreaPathMapper } from '../../../src/integrations/ado/area-path-mapper.js';
+
+const { selectedProject } = await inquirer.prompt([{
+  type: 'list',
+  name: 'selectedProject',
+  message: 'Select ADO project to import area paths from:',
+  choices: allProjects.map(p => ({ name: p.name, value: p.name }))
+}]);
+
+const mapper = new AreaPathMapper({
+  credentials: { organization: org, pat: parsed.AZURE_DEVOPS_PAT },
+  project: selectedProject
+});
+
+// Fetch area path tree
+const areaPathTree = await mapper.fetchAreaPaths();
+
+// Get granularity suggestion
+const suggestion = mapper.suggestGranularity(areaPathTree);
+console.log(`\n💡 Suggestion: ${suggestion.suggested}`);
+console.log(`   ${suggestion.reasoning}\n`);
+
+// Prompt for granularity (if not provided via CLI)
+const granularity = args.granularity || await mapper.promptAreaPathGranularity(areaPathTree);
+
+// Flatten area paths with selected granularity
+const areaPaths = mapper.flattenAreaPaths(areaPathTree, granularity);
+
+console.log(`\n📊 ${areaPaths.length} project(s) will be created from area paths:\n`);
+areaPaths.forEach(ap => {
+  const projectId = mapper.mapToProjectId(ap.path);
+  console.log(`   ✨ ${ap.path} → ${projectId}`);
+});
+```
+
+### Step 4: Dry-Run or Execute
+```typescript
+if (args.dryRun) {
+  console.log('\n🔎 DRY RUN: No changes will be made.\n');
+  console.log('The following projects would be configured:');
+  areaPaths.forEach(ap => {
+    const projectId = mapper.mapToProjectId(ap.path);
+    console.log(`   ✨ ${projectId} (${ap.path})`);
+  });
+  console.log(`\nTotal: ${areaPaths.length} projects would be configured\n`);
+  return;
+}
+
+// Confirm import
+const { confirmed } = await inquirer.prompt([{
+  type: 'confirm',
+  name: 'confirmed',
+  message: `Configure ${areaPaths.length} project(s) from area paths?`,
+  default: true
+}]);
+
+if (!confirmed) {
+  console.log('⏭️  Import cancelled.');
+  return;
+}
+```
+
+### Step 5: Update Configuration
+```typescript
+import { getConfigManager } from '../../../src/core/config/index.js';
+
+const configManager = getConfigManager(process.cwd());
+
+// Build area path configuration
+const areaPathConfig: Record<string, string[]> = {};
+
+for (const ap of areaPaths) {
+  const projectId = mapper.mapToProjectId(ap.path);
+  areaPathConfig[projectId] = [ap.path];
+}
+
+// Update configuration
+await configManager.update({
+  issueTracker: {
+    provider: 'ado',
+    ado: {
+      organization: org,
+      project: selectedProject,
+      areaPathMapping: areaPathConfig,
+      granularity
+    }
+  }
+});
+
+// Update .env file
+import { updateEnvFile } from '../../../src/utils/env-manager.js';
+
+await updateEnvFile('AZURE_DEVOPS_PROJECT', selectedProject);
+
+// Write area paths to .env (comma-separated)
+const areaPathList = areaPaths.map(ap => ap.path).join(',');
+await updateEnvFile('AZURE_DEVOPS_AREA_PATHS', areaPathList);
+
+console.log('\n✅ Projects configured successfully!\n');
+console.log(`Organization: ${org}`);
+console.log(`Project: ${selectedProject}`);
+console.log(`Granularity: ${granularity}`);
+console.log(`\nArea paths configured:\n   ${areaPathList.split(',').join('\n   ')}\n`);
+```
+
+### Step 6: Resume Support
+```typescript
+if (args.resume) {
+  const { CacheManager } = await import('../../../src/core/cache/cache-manager.js');
+  const cacheManager = new CacheManager(process.cwd());
+
+  const importState = await cacheManager.get('ado-import-state');
+
+  if (!importState) {
+    console.log('⚠️  No import state found. Use without --resume to start fresh.');
+    return;
+  }
+
+  console.log(`\n📂 Resuming from: ${importState.lastAreaPath} (${importState.completed}/${importState.total})`);
+
+  // Skip already-processed area paths
+  const remainingPaths = areaPaths.filter(ap => !importState.processed.includes(ap.path));
+
+  // Continue import with remaining paths
+  // (use same logic as Step 5)
+}
+```
+
+## Examples
+
+### Example 1: Basic Import with Area Paths
+**User**: `/specweave-ado:import-projects`
+
+**Output**:
+```
+📋 Organization: mycompany
+   Current project: Platform
+
+✓ Found 5 accessible project(s)
+
+Select ADO project to import area paths from:
+> Platform
+
+💡 Suggestion: two-level
+   Balanced hierarchy (8 two-level areas). Recommended granularity.
+
+Select area path granularity for project organization:
+> Two-level (8 projects) - e.g., Backend-API, Backend-Database
+
+📊 8 project(s) will be created from area paths:
+
+   ✨ Platform/Backend/API → backend-api
+   ✨ Platform/Backend/Database → backend-database
+   ✨ Platform/Frontend/Web → frontend-web
+   ✨ Platform/Frontend/Admin → frontend-admin
+   ✨ Platform/Mobile/iOS → mobile-ios
+   ✨ Platform/Mobile/Android → mobile-android
+   ✨ Platform/Infrastructure/Cloud → infrastructure-cloud
+   ✨ Platform/Infrastructure/Network → infrastructure-network
+
+Configure 8 project(s) from area paths? (Y/n)
+
+✅ Projects configured successfully!
+
+Organization: mycompany
+Project: Platform
+Granularity: two-level
+
+Area paths configured:
+   Platform/Backend/API
+   Platform/Backend/Database
+   Platform/Frontend/Web
+   Platform/Frontend/Admin
+   Platform/Mobile/iOS
+   Platform/Mobile/Android
+   Platform/Infrastructure/Cloud
+   Platform/Infrastructure/Network
+```
+
+### Example 2: Top-Level Only
+**User**: `/specweave-ado:import-projects --granularity top-level`
+
+**Output**:
+```
+Select area path granularity: top-level (forced via CLI)
+
+📊 3 project(s) will be created from area paths:
+
+   ✨ Platform/Backend → backend
+   ✨ Platform/Frontend → frontend
+   ✨ Platform/Mobile → mobile
+```
+
+### Example 3: Dry-Run
+**User**: `/specweave-ado:import-projects --dry-run`
+
+**Output**:
+```
+🔎 DRY RUN: No changes will be made.
+
+The following projects would be configured:
+   ✨ backend-api (Platform/Backend/API)
+   ✨ backend-database (Platform/Backend/Database)
+   ✨ frontend-web (Platform/Frontend/Web)
+
+Total: 8 projects would be configured
+```
+
+## Important Notes
+
+- **Multi-Project Organization**: Uses area paths to create logical project separation
+- **Granularity Control**: Top-level, two-level, or full-tree based on hierarchy complexity
+- **Atomic Updates**: Uses temp file + rename to prevent corruption
+- **Progress Tracking**: Shows progress bar for large hierarchies (> 50 area paths)
+- **Resume Support**: Interrupted imports can be resumed with `--resume`
+
+## Related Commands
+
+- `/specweave:init` - Initial SpecWeave setup
+- `/specweave-ado:sync` - Sync increments with ADO work items
+- `/specweave-ado:refresh-cache` - Clear cached ADO data
+
+## Error Handling
+
+- **Missing Credentials**: Prompt user to run `specweave init` first
+- **API Errors**: Show clear error message with suggestion
+- **No Area Paths**: Fallback to single-project mode
+- **Permission Errors**: Check ADO PAT scopes
+
+---
+
+**Multi-Project Excellence**: This command enables sophisticated multi-project organization in Azure DevOps using area paths, perfect for large teams with complex hierarchies.

package/plugins/specweave-alternatives/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "specweave-alternatives",
+  "version": "0.24.0",
+  "description": "Technology stack alternatives analysis using BMAD method - Best, Most Appropriate, Design decisions for architecture choices",
+  "author": {
+    "name": "Anton Abyzov",
+    "email": "anton.abyzov@gmail.com"
+  },
+  "hooks": {}
+}

package/plugins/specweave-alternatives/commands/alternatives-analyze.md

@@ -0,0 +1,336 @@
+# Alternatives Analyze - Technology Stack Decision Analysis
+
+Analyze technology stack alternatives using the **BMAD** (Best, Most Appropriate, Design) framework. Make informed decisions about databases, frameworks, cloud providers, languages, and architectural patterns by evaluating tradeoffs, costs, and long-term implications.
+
+## Usage
+
+```
+/specweave-alternatives:alternatives-analyze <category> [context] [options]
+```
+
+## What I Do
+
+1. **Identify Alternatives**: List all viable options for the technology category
+2. **BMAD Analysis**: Evaluate using Best/Most Appropriate/Design criteria
+3. **Tradeoff Matrix**: Compare pros/cons, costs, learning curve, ecosystem
+4. **Context Scoring**: Weight factors based on your specific requirements
+5. **Recommendation**: Provide data-driven recommendation with rationale
+
+## Technology Categories
+
+### 1. Databases
+```bash
+/specweave-alternatives:alternatives-analyze database \
+  --requirements "high-throughput,strong-consistency,cloud-native" \
+  --scale "startup"
+```
+
+**Analyzes**: PostgreSQL, MySQL, MongoDB, DynamoDB, Firestore, CockroachDB, Cassandra
+
+### 2. Backend Frameworks
+```bash
+/specweave-alternatives:alternatives-analyze backend-framework \
+  --language typescript \
+  --requirements "fast-development,type-safe,good-orms"
+```
+
+**Analyzes**: Express, Fastify, NestJS, Hono, Elysia, tRPC
+
+### 3. Frontend Frameworks
+```bash
+/specweave-alternatives:alternatives-analyze frontend-framework \
+  --requirements "SEO,performance,large-team" \
+  --existing-stack "React"
+```
+
+**Analyzes**: Next.js, Remix, Astro, SvelteKit, Nuxt, Gatsby
+
+### 4. Cloud Providers
+```bash
+/specweave-alternatives:alternatives-analyze cloud-provider \
+  --workload "containerized-microservices" \
+  --scale "enterprise" \
+  --constraints "EU-data-residency"
+```
+
+**Analyzes**: AWS, GCP, Azure, Hetzner, DigitalOcean, Fly.io
+
+### 5. Message Queues
+```bash
+/specweave-alternatives:alternatives-analyze message-queue \
+  --requirements "exactly-once,high-throughput,stream-processing" \
+  --scale "100k-msgs-sec"
+```
+
+**Analyzes**: Kafka, RabbitMQ, Redis Streams, AWS SQS, Google Pub/Sub, NATS
+
+### 6. Authentication
+```bash
+/specweave-alternatives:alternatives-analyze auth \
+  --requirements "social-login,SSO,MFA,compliance" \
+  --constraints "GDPR,SOC2"
+```
+
+**Analyzes**: Auth0, Clerk, Supabase Auth, Firebase Auth, AWS Cognito, custom JWT
+
+## BMAD Framework
+
+### **B**est - Industry Gold Standard
+What is considered the **best practice** in the industry?
+
+- **Criteria**: Battle-tested, widely adopted, comprehensive features
+- **Examples**:
+  - Database: PostgreSQL (ACID compliance, robustness)
+  - Queue: Kafka (high throughput, durability)
+  - Cloud: AWS (feature breadth, enterprise tooling)
+
+### **M**ost Appropriate - Context Fit
+What is **most appropriate** for YOUR specific context?
+
+- **Criteria**: Team expertise, budget, timeline, scale
+- **Factors**:
+  - **Team Size**: Startup (2-5) vs Scale-up (20-50) vs Enterprise (100+)
+  - **Budget**: Free tier vs $100/mo vs $10k/mo vs unlimited
+  - **Timeline**: POC (1 week) vs MVP (3 months) vs Production (1 year)
+  - **Scale**: 100 users vs 10k users vs 1M users
+
+### **D**esign - Architectural Alignment
+How does this fit your **overall design** and long-term vision?
+
+- **Criteria**: System coherence, vendor lock-in, migration path
+- **Considerations**:
+  - **Vendor Lock-in**: Open-source vs proprietary
+  - **Migration Path**: Can you switch later? At what cost?
+  - **Ecosystem**: Libraries, tools, community support
+  - **Future-proofing**: Technology trajectory, maintenance
+
+## Analysis Output
+
+### Tradeoff Matrix
+
+```markdown
+## Database Alternatives Analysis
+
+### Context
+- **Team Size**: 5 engineers (3 backend, 2 fullstack)
+- **Current Stage**: Seed-funded startup
+- **Scale**: 1,000 active users → 50,000 in 12 months
+- **Budget**: $500/mo infrastructure
+- **Constraints**: GDPR compliance required
+
+### Options Evaluated
+
+| Option        | Type       | Cost/mo | Learn Curve | Maturity | Score |
+|---------------|------------|---------|-------------|----------|-------|
+| PostgreSQL    | Relational | $25     | Medium      | ⭐⭐⭐⭐⭐ | 92    |
+| MongoDB       | Document   | $57     | Low         | ⭐⭐⭐⭐   | 78    |
+| DynamoDB      | NoSQL      | $50     | High        | ⭐⭐⭐⭐   | 71    |
+| Firestore     | Document   | $30     | Low         | ⭐⭐⭐     | 68    |
+| MySQL         | Relational | $25     | Medium      | ⭐⭐⭐⭐⭐ | 85    |
+
+### BMAD Analysis
+
+#### Best: PostgreSQL
+- ✅ **Strengths**: ACID compliance, JSON support, full-text search, PostGIS
+- ✅ **Ecosystem**: Rich ORM support (Prisma, Drizzle, TypeORM)
+- ✅ **Flexibility**: Relational + document (JSON columns)
+- ⚠️ **Considerations**: Requires schema management
+
+#### Most Appropriate: PostgreSQL (Supabase)
+- ✅ **Team Fit**: SQL skills on team, Prisma ORM familiarity
+- ✅ **Budget Fit**: $25/mo for 100GB database (within budget)
+- ✅ **Timeline Fit**: Fast setup with Supabase (2 hours vs 2 days self-hosted)
+- ✅ **Scale Fit**: Handles 50k users with vertical scaling
+- ✅ **Compliance**: EU region available, GDPR-ready
+
+#### Design: PostgreSQL with Migration Plan
+- ✅ **No Lock-in**: Standard PostgreSQL (can migrate to RDS, self-hosted)
+- ✅ **Ecosystem**: TypeScript-first with Prisma
+- ✅ **Future Path**: Scale with read replicas, connection pooling (PgBouncer)
+- ⚠️ **Migration Risk**: Low - standard SQL export/import
+
+### Recommendation
+
+**Choose: PostgreSQL (hosted on Supabase)**
+
+**Rationale:**
+1. ✅ Aligns with team's SQL expertise
+2. ✅ Fits budget ($25/mo vs $500 budget)
+3. ✅ Supports rapid development (Prisma ORM)
+4. ✅ No vendor lock-in (standard PostgreSQL)
+5. ✅ Clear scaling path (read replicas, PgBouncer)
+6. ✅ GDPR compliance out-of-the-box
+
+**Alternative if requirements change:**
+- **If need extreme scale**: Consider CockroachDB (distributed SQL)
+- **If need real-time**: Consider Firestore + PostgreSQL hybrid
+- **If team prefers NoSQL**: MongoDB Atlas (better maturity than DynamoDB for startups)
+
+### Implementation Path
+
+1. **Week 1**: Set up Supabase project, configure EU region
+2. **Week 2**: Design schema with Prisma, enable Row Level Security (RLS)
+3. **Week 3**: Implement connection pooling, set up backups
+4. **Week 4**: Load testing, optimize queries, add indexes
+
+### Long-term Monitoring
+
+- **Metric**: Connection pool utilization
+- **Alert**: >80% CPU on database
+- **Review**: Quarterly review of costs vs scale
+- **Trigger**: If cost >$200/mo OR latency >100ms p95, re-evaluate
+```
+
+## Options
+
+### Context Options
+- `--scale <level>` - Startup, scale-up, enterprise (default: startup)
+- `--team-size <number>` - Number of engineers
+- `--budget <amount>` - Monthly budget for this component
+- `--timeline <duration>` - Time to production (1 week, 1 month, 3 months, etc.)
+
+### Requirement Options
+- `--requirements <list>` - Comma-separated requirements (e.g., "ACID,scalability,cost-effective")
+- `--constraints <list>` - Hard constraints (e.g., "GDPR,open-source,EU-region")
+- `--existing-stack <tech>` - Technologies already in use
+- `--language <lang>` - Preferred programming language
+
+### Analysis Options
+- `--format <format>` - Output format: markdown, json, html (default: markdown)
+- `--depth <level>` - Analysis depth: quick, standard, deep (default: standard)
+- `--include-costs` - Include detailed cost breakdown (default: true)
+- `--include-migration` - Include migration complexity analysis (default: true)
+
+## Use Cases
+
+### 1. Green field Project Planning
+Choose the right stack before writing any code.
+
+### 2. Technology Replacement
+Evaluate alternatives when migrating away from legacy systems.
+
+### 3. Cost Optimization
+Find cheaper alternatives that meet the same requirements.
+
+### 4. Scale Planning
+Identify when current technology won't scale and what to migrate to.
+
+### 5. Team Skill Alignment
+Choose technologies that match team expertise or learning goals.
+
+## Advanced Features
+
+### Multi-Criteria Decision Analysis (MCDA)
+
+```markdown
+### Weighted Criteria
+
+| Criteria         | Weight | PostgreSQL | MongoDB | DynamoDB |
+|------------------|--------|------------|---------|----------|
+| Cost             | 25%    | 9/10       | 6/10    | 7/10     |
+| Performance      | 20%    | 8/10       | 8/10    | 9/10     |
+| Developer UX     | 20%    | 9/10       | 8/10    | 6/10     |
+| Scalability      | 15%    | 7/10       | 8/10    | 10/10    |
+| Ecosystem        | 10%    | 10/10      | 8/10    | 7/10     |
+| Learning Curve   | 10%    | 7/10       | 9/10    | 5/10     |
+| **Total Score**  |        | **8.4**    | **7.7** | **7.3**  |
+```
+
+### Total Cost of Ownership (TCO)
+
+```markdown
+### 3-Year TCO Comparison
+
+| Cost Component         | PostgreSQL | MongoDB | DynamoDB |
+|------------------------|------------|---------|----------|
+| **Infrastructure**     |            |         |          |
+| - Database hosting     | $900       | $2,050  | $1,800   |
+| - Backup storage       | $120       | $240    | $360     |
+| - Monitoring           | $240       | $480    | $0       |
+| **Engineering**        |            |         |          |
+| - Initial setup        | $4,000     | $3,000  | $6,000   |
+| - Ongoing maintenance  | $6,000     | $4,000  | $2,000   |
+| - Migration risk       | $0         | $8,000  | $15,000  |
+| **Total 3-Year Cost**  | **$11,260**| **$17,770** | **$25,160** |
+```
+
+### Risk Analysis
+
+```markdown
+### Risk Matrix
+
+| Risk                  | Probability | Impact | Mitigation                      |
+|-----------------------|-------------|--------|---------------------------------|
+| Vendor shutdown       | Low (5%)    | High   | Use open-source alternative     |
+| Cost explosion        | Medium (30%)| High   | Set up billing alerts, reserves |
+| Performance issues    | Low (10%)   | Medium | Load testing, query optimization|
+| Team knowledge gap    | Medium (20%)| Medium | Training, pair programming      |
+| Lock-in constraints   | High (60%)  | Medium | Standard interfaces, abstraction|
+```
+
+## Examples
+
+### Analyze Database Options
+```bash
+/specweave-alternatives:alternatives-analyze database \
+  --scale startup \
+  --budget 200 \
+  --requirements "ACID,JSON-support,full-text-search" \
+  --constraints "open-source,EU-hosting"
+```
+
+### Compare Cloud Providers
+```bash
+/specweave-alternatives:alternatives-analyze cloud-provider \
+  --workload "containerized-apps" \
+  --scale "scale-up" \
+  --budget 5000 \
+  --constraints "multi-region,SOC2"
+```
+
+### Frontend Framework Decision
+```bash
+/specweave-alternatives:alternatives-analyze frontend-framework \
+  --existing-stack React \
+  --requirements "SEO,SSR,static-generation" \
+  --team-size 8
+```
+
+### Message Queue Selection
+```bash
+/specweave-alternatives:alternatives-analyze message-queue \
+  --scale enterprise \
+  --requirements "exactly-once,replay,stream-processing" \
+  --throughput "500k-msgs-sec"
+```
+
+## Related Commands
+
+- `/specweave-alternatives:cost-compare` - Detailed cost comparison only
+- `/specweave-alternatives:migration-plan` - Generate migration plan from A to B
+- `/specweave-cost-optimizer:analyze` - Optimize costs for chosen stack
+
+## Best Practices
+
+1. **Start with Requirements**: Define hard requirements vs nice-to-haves
+2. **Include Team Context**: Consider team skills, not just technology merits
+3. **Plan for Change**: Evaluate migration difficulty even if not planning to migrate
+4. **Use Real Numbers**: Actual budget, actual scale, actual timeline
+5. **Re-evaluate Periodically**: Technology landscape changes, reassess every 12-18 months
+
+## Limitations
+
+- **Analysis is point-in-time**: Technology landscape evolves rapidly
+- **Costs are estimates**: Actual costs depend on usage patterns
+- **Assumes typical use cases**: Edge cases may favor different technologies
+- **Human judgment required**: Framework provides data, but final decision is yours
+
+## Activation Keywords
+
+- "Which database should I use?"
+- "Compare PostgreSQL vs MongoDB vs DynamoDB"
+- "Best cloud provider for startups"
+- "Should I use Next.js or Remix?"
+- "Kafka vs RabbitMQ decision"
+- "Technology stack recommendations"
+- "BMAD method analysis"