claude-autopm 2.8.2 → 2.8.3

package/packages/plugin-databases/plugin.json

@@ -0,0 +1,237 @@
+{
+  "name": "@claudeautopm/plugin-databases",
+  "version": "2.0.0",
+  "schemaVersion": "2.0",
+  "displayName": "Database & Data Storage",
+  "description": "Complete database plugin with PostgreSQL, MongoDB, Redis, BigQuery, and Cosmos DB experts, database rules, and optimization scripts",
+  "category": "databases",
+  "metadata": {
+    "category": "Databases & Data Storage",
+    "author": "ClaudeAutoPM Team",
+    "license": "MIT",
+    "homepage": "https://github.com/rafeekpro/ClaudeAutoPM",
+    "repository": {
+      "type": "git",
+      "url": "git+https://github.com/rafeekpro/ClaudeAutoPM.git",
+      "directory": "packages/plugin-databases"
+    },
+    "size": "~20 KB (gzipped)",
+    "required": false,
+    "tags": ["databases", "sql", "nosql", "postgresql", "mongodb", "redis", "bigquery", "cosmosdb", "data-warehouse", "caching"]
+  },
+  "commands": [
+    {
+      "name": "db-optimize",
+      "file": "commands/db-optimize.md",
+      "description": "Optimize database performance for PostgreSQL, MongoDB, and Redis",
+      "category": "optimization",
+      "tags": ["database", "optimization", "performance", "indexing", "postgresql", "mongodb", "redis"],
+      "requiredAgents": ["postgresql-expert", "mongodb-expert", "redis-expert"],
+      "context7": [
+        "/websites/postgresql",
+        "/mongodb/mongo",
+        "/redis/redis-py"
+      ]
+    }
+  ],
+  "agents": [
+    {
+      "name": "postgresql-expert",
+      "file": "agents/postgresql-expert.md",
+      "category": "databases",
+      "description": "PostgreSQL database design, optimization, and management. Expert in SQL queries, indexing strategies, performance tuning, replication, partitioning, and advanced features like JSONB and full-text search.",
+      "version": "2.0.0",
+      "tags": ["postgresql", "sql", "database", "indexing", "performance", "replication"],
+      "mcp": ["postgresql"],
+      "context7": [
+        "/websites/postgresql",
+        "/websites/postgresql-current",
+        "/porsager/postgres"
+      ]
+    },
+    {
+      "name": "mongodb-expert",
+      "file": "agents/mongodb-expert.md",
+      "category": "databases",
+      "description": "MongoDB database design, aggregation pipelines, and performance optimization. Expert in document modeling, sharding, replication, indexing strategies, and MongoDB Atlas.",
+      "version": "2.0.0",
+      "tags": ["mongodb", "nosql", "document-db", "aggregation", "sharding", "atlas"],
+      "mcp": ["mongodb"],
+      "context7": [
+        "/mongodb/docs",
+        "/mongodb/mongo",
+        "/automattic/mongoose",
+        "/mongodb/node-mongodb-native"
+      ]
+    },
+    {
+      "name": "redis-expert",
+      "file": "agents/redis-expert.md",
+      "category": "caching",
+      "description": "Redis caching, pub/sub messaging, and data structure operations. Expert in Redis Cluster, persistence strategies, Lua scripting, and performance optimization.",
+      "version": "2.0.0",
+      "tags": ["redis", "caching", "pub-sub", "in-memory", "data-structures", "performance"],
+      "mcp": ["redis"],
+      "context7": [
+        "/websites/redis_io",
+        "/redis/node-redis",
+        "/redis/go-redis"
+      ]
+    },
+    {
+      "name": "bigquery-expert",
+      "file": "agents/bigquery-expert.md",
+      "category": "data-warehouse",
+      "description": "BigQuery data warehouse design, SQL optimization, and analytics engineering. Expert in partitioning, clustering, materialized views, BigQuery ML, and cost optimization.",
+      "version": "2.0.0",
+      "tags": ["bigquery", "data-warehouse", "analytics", "sql", "gcp", "ml", "cost-optimization"],
+      "mcp": [],
+      "context7": [
+        "/websites/cloud_google-bigquery",
+        "/googleapis/python-bigquery",
+        "/googleapis/nodejs-bigquery"
+      ]
+    },
+    {
+      "name": "cosmosdb-expert",
+      "file": "agents/cosmosdb-expert.md",
+      "category": "databases",
+      "description": "Azure Cosmos DB design and optimization across all APIs (Core SQL, MongoDB, Cassandra, Gremlin, Table). Expert in global distribution, consistency levels, partitioning strategies, and cost optimization.",
+      "version": "2.0.0",
+      "tags": ["cosmosdb", "azure", "nosql", "multi-model", "global-distribution", "consistency"],
+      "mcp": [],
+      "context7": [
+        "/websites/learn_microsoft-en-us-azure-cosmos-db",
+        "/microsoftdocs/azure-docs"
+      ]
+    }
+  ],
+  "rules": [
+    {
+      "name": "database-management-strategy",
+      "file": "rules/database-management-strategy.md",
+      "priority": "high",
+      "description": "Required strategy for managing databases across all project environments with Context7-verified best practices",
+      "tags": ["database", "strategy", "environments", "best-practices", "postgresql", "mongodb", "redis", "bigquery", "cosmosdb"],
+      "appliesTo": ["commands", "agents"],
+      "enforcesOn": ["postgresql-expert", "mongodb-expert", "redis-expert", "bigquery-expert", "cosmosdb-expert"]
+    },
+    {
+      "name": "database-pipeline",
+      "file": "rules/database-pipeline.md",
+      "priority": "high",
+      "description": "Critical database operations pipelines for migrations, optimization, data warehousing, caching, and backups",
+      "tags": ["database", "pipeline", "migrations", "optimization", "backup", "caching", "data-warehouse"],
+      "appliesTo": ["commands", "agents"],
+      "enforcesOn": ["postgresql-expert", "mongodb-expert", "redis-expert", "bigquery-expert", "cosmosdb-expert"]
+    }
+  ],
+  "scripts": [
+    {
+      "name": "postgres-index-analyze",
+      "file": "scripts/examples/postgres-index-analyze.sh",
+      "description": "Analyze PostgreSQL indexes for unused indexes, hit ratio, and missing foreign key indexes",
+      "type": "example",
+      "executable": true,
+      "category": "postgresql",
+      "tags": ["postgresql", "indexing", "performance", "analysis"]
+    },
+    {
+      "name": "mongodb-shard-check",
+      "file": "scripts/examples/mongodb-shard-check.sh",
+      "description": "Check MongoDB sharded collection index consistency across all shards",
+      "type": "example",
+      "executable": true,
+      "category": "mongodb",
+      "tags": ["mongodb", "sharding", "indexing", "consistency"]
+    },
+    {
+      "name": "redis-cache-stats",
+      "file": "scripts/examples/redis-cache-stats.sh",
+      "description": "Analyze Redis cache performance including hit/miss ratio, memory usage, and slow log",
+      "type": "example",
+      "executable": true,
+      "category": "redis",
+      "tags": ["redis", "caching", "performance", "monitoring"]
+    },
+    {
+      "name": "bigquery-cost-analyze",
+      "file": "scripts/examples/bigquery-cost-analyze.sh",
+      "description": "Analyze BigQuery costs and optimization opportunities including storage and partitioning",
+      "type": "example",
+      "executable": true,
+      "category": "bigquery",
+      "tags": ["bigquery", "cost-optimization", "partitioning", "clustering"]
+    },
+    {
+      "name": "cosmosdb-ru-optimize",
+      "file": "scripts/examples/cosmosdb-ru-optimize.sh",
+      "description": "Analyze Azure Cosmos DB RU/s optimization and partition distribution",
+      "type": "example",
+      "executable": true,
+      "category": "cosmosdb",
+      "tags": ["cosmosdb", "ru-optimization", "partitioning", "cost"]
+    }
+  ],
+  "features": {
+    "postgresql_database": {
+      "enabled": true,
+      "description": "PostgreSQL relational database with advanced features"
+    },
+    "mongodb_database": {
+      "enabled": true,
+      "description": "MongoDB document database with sharding and aggregation"
+    },
+    "redis_caching": {
+      "enabled": true,
+      "description": "Redis in-memory caching and pub/sub messaging"
+    },
+    "bigquery_warehouse": {
+      "enabled": true,
+      "description": "BigQuery data warehouse with ML and analytics"
+    },
+    "cosmosdb_database": {
+      "enabled": true,
+      "description": "Azure Cosmos DB multi-model globally distributed database"
+    },
+    "database_optimization": {
+      "enabled": true,
+      "description": "Query optimization, indexing, and performance tuning"
+    },
+    "cost_optimization": {
+      "enabled": true,
+      "description": "Database cost analysis and optimization strategies"
+    }
+  },
+  "dependencies": [],
+  "peerPlugins": [
+    "@claudeautopm/plugin-core"
+  ],
+  "mcpServers": {
+    "recommended": [
+      "postgresql",
+      "mongodb",
+      "redis"
+    ],
+    "optional": [
+      "azure-cli",
+      "gcp"
+    ]
+  },
+  "keywords": [
+    "claudeautopm",
+    "plugin",
+    "databases",
+    "postgresql",
+    "mongodb",
+    "redis",
+    "bigquery",
+    "cosmosdb",
+    "sql",
+    "nosql",
+    "data-warehouse",
+    "caching",
+    "optimization"
+  ],
+  "compatibleWith": ">=3.0.0"
+}

package/packages/plugin-databases/rules/database-management-strategy.md

@@ -0,0 +1,146 @@
+# Rule: Database Management Strategy
+
+This document outlines the required strategy for managing databases across all project environments, incorporating Context7-verified best practices for PostgreSQL, MongoDB, Redis, BigQuery, and Cosmos DB.
+
+| Environment         | Tool / Service                  | Lifecycle / Purpose                 | Data Source                               | Persistence               |
+| ------------------- | ------------------------------- | ----------------------------------- | ----------------------------------------- | ------------------------- |
+| **Local (Dev)** | `docker-compose`                | Long-running, per-developer         | Migrations + Developer Seeds              | **Yes** (Named Volume)    |
+| **CI/CD (Tests)** | `kubectl run`                   | **Ephemeral**, per-PR/commit        | Migrations + Test Seeds                   | **No** (Clean for every run) |
+| **Staging** | Managed Cloud DB (e.g., RDS)    | Long-running, shared by team        | Sanitized/Anonymized Production Dump      | **Yes** (Persistent)      |
+| **Production** | Managed Cloud DB (High-Availability) | Long-running, critical user data    | Live User Data                            | **Yes** (HA + Backups)    |
+
+## Key Principles
+
+### 1. Local Development
+- Use a named Docker volume to persist data between `docker compose up/down` cycles
+- PostgreSQL: Use official image with version pinning
+- MongoDB: Use named volumes for `/data/db`
+- Redis: Use AOF (Append-Only File) for persistence in dev
+
+### 2. CI/CD Testing
+- Database MUST be created from scratch for every test run
+- DO NOT use persistent volumes in CI for perfect isolation
+- Use lightweight containers for speed (Alpine-based images)
+- Implement health checks before running tests
+
+### 3. Staging Environment
+- Schema must be an exact mirror of production
+- Data should be a recent, anonymized copy of production data
+- Use automated refresh scripts for staging data
+- Test backup/restore procedures regularly
+
+### 4. Production Best Practices
+
+#### PostgreSQL (Context7: /websites/postgresql)
+- Use B-tree indexes for equality and range queries
+- Implement partial indexes for filtered queries
+- Use `EXPLAIN ANALYZE` for query optimization
+- Monitor `pg_stat_user_indexes` for index usage
+
+#### MongoDB (Context7: /mongodb/docs)
+- Implement proper sharding strategies for scale
+- Use aggregation pipeline for complex queries
+- Monitor index inconsistencies with `$indexStats`
+- Use compound indexes in query filter order
+
+#### Redis (Context7: /websites/redis_io)
+- Implement client-side caching patterns
+- Use appropriate data structures (Hash, Set, Sorted Set)
+- Configure AOF + RDB for persistence
+- Monitor memory usage and implement eviction policies
+
+#### Azure Cosmos DB (Context7: /websites/learn_microsoft-en-us-azure-cosmos-db)
+- Choose appropriate consistency level (Session for most cases)
+- Design partition keys for even distribution
+- Use TTL for automatic data expiration
+- Monitor RU/s consumption and optimize queries
+
+#### BigQuery (Context7: /websites/cloud_google-bigquery)
+- Partition tables by date/timestamp for query performance
+- Cluster tables by commonly filtered columns
+- Use `_PARTITIONTIME` for efficient partition pruning
+- Monitor costs with `INFORMATION_SCHEMA.TABLE_STORAGE`
+
+### 5. Migration Strategy
+- All schema changes MUST be handled by migration tools:
+  - PostgreSQL: Alembic, Flyway, or native migrations
+  - MongoDB: migrate-mongo or custom scripts
+  - BigQuery: Declarative schema with version control
+- No manual `ALTER TABLE` or schema modifications
+- Always include rollback procedures
+
+### 6. Backup and Recovery
+- **PostgreSQL**: pg_dump with custom format, point-in-time recovery
+- **MongoDB**: mongodump with --oplog for consistency
+- **Redis**: RDB snapshots + AOF for durability
+- **Cosmos DB**: Automatic backups with configurable retention
+- **BigQuery**: Table snapshots and time travel queries
+
+### 7. Performance Monitoring
+- Track slow queries across all database systems
+- Monitor connection pool utilization
+- Implement alerting for query timeout
+- Use database-specific monitoring tools:
+  - PostgreSQL: pg_stat_statements
+  - MongoDB: Database Profiler
+  - Redis: INFO command, redis-cli --stat
+  - BigQuery: Query execution details
+  - Cosmos DB: Request unit metrics
+
+## Context7-Verified Patterns
+
+### PostgreSQL Indexing
+```sql
+-- B-tree for equality and range
+CREATE INDEX idx_users_email ON users(email);
+
+-- Partial index for filtered queries
+CREATE INDEX idx_orders_pending ON orders(order_date)
+WHERE status = 'pending';
+
+-- Covering index with INCLUDE
+CREATE INDEX idx_orders_customer ON orders(customer_id)
+INCLUDE (order_date, amount);
+```
+
+### MongoDB Aggregation
+```javascript
+// Check for index inconsistencies in sharded collections
+db.collection.aggregate([
+  {$indexStats: {}},
+  {$group: {_id: null, indexDoc: {$push: "$$ROOT"}, allShards: {$addToSet: "$shard"}}}
+]);
+```
+
+### Redis Caching Pattern
+```redis
+# Client-side caching with placeholder
+SET foo "caching-in-progress"
+GET foo
+# Replace with actual value after computation
+```
+
+### BigQuery Partitioning
+```sql
+CREATE TABLE my_table (
+  id INT64,
+  event_timestamp TIMESTAMP,
+  category STRING
+)
+PARTITION BY DATE(event_timestamp)
+CLUSTER BY category;
+```
+
+### Cosmos DB Partitioning
+```json
+{
+  "partitionKey": {
+    "paths": ["/userId"],
+    "kind": "Hash"
+  }
+}
+```
+
+## Compliance
+
+All database operations must follow these strategies. Deviations require architectural review and documentation in CLAUDE.md.

package/packages/plugin-databases/rules/database-pipeline.md

@@ -0,0 +1,316 @@
+# Database Operations Pipeline
+
+> **CRITICAL**: Database operations require specialized workflows for safety and performance.
+
+## 1. DATABASE MIGRATION PIPELINE
+
+**Trigger**: Any schema change or migration
+**Sequence**:
+
+```
+1. postgresql-expert/mongodb-expert → Analyze current schema
+2. Query Context7 for migration best practices
+3. Write migration with rollback plan
+4. test-runner → Test migration on dev database
+5. Create backup verification test
+6. Document migration in changelog
+7. Never run migrations without rollback plan
+```
+
+**Context7 Best Practices**:
+- PostgreSQL: Use transactional DDL when possible
+- MongoDB: Test on replica set before production
+- Always verify index creation doesn't block writes
+
+## 2. QUERY OPTIMIZATION PIPELINE
+
+**Trigger**: Slow query or performance issue
+**Sequence**:
+
+```
+1. postgresql-expert → Analyze query plan (EXPLAIN ANALYZE)
+2. Query Context7 for optimization patterns
+3. Identify missing indexes or inefficient operations
+4. Write performance test (must show improvement)
+5. Implement optimization
+6. test-runner → Verify no functionality regression
+7. Document optimization in CLAUDE.md
+```
+
+**PostgreSQL Optimization** (Context7: /websites/postgresql):
+```sql
+-- Use EXPLAIN ANALYZE to identify bottlenecks
+EXPLAIN ANALYZE SELECT * FROM orders WHERE customer_id = 123;
+
+-- Optimize with appropriate index
+CREATE INDEX idx_orders_customer_id ON orders(customer_id);
+
+-- Verify improvement
+EXPLAIN ANALYZE SELECT * FROM orders WHERE customer_id = 123;
+```
+
+**MongoDB Optimization** (Context7: /mongodb/docs):
+```javascript
+// Use explain() for aggregation pipelines
+db.collection.aggregate([
+  {$match: {status: "active"}},
+  {$group: {_id: "$category", total: {$sum: 1}}}
+]).explain("executionStats");
+
+// Create compound index in query order
+db.collection.createIndex({status: 1, category: 1});
+```
+
+**Redis Optimization** (Context7: /websites/redis_io):
+- Use SCAN instead of KEYS for production
+- Implement pipeline for multiple commands
+- Use appropriate data structures (Hash vs String)
+
+## 3. DATA WAREHOUSE PIPELINE
+
+**Trigger**: BigQuery/CosmosDB implementation
+**Sequence**:
+
+```
+1. bigquery-expert/cosmosdb-expert → Design schema
+2. Query Context7 for partitioning/clustering best practices
+3. Create partitioning/sharding strategy
+4. Implement ETL/ELT pipeline
+5. test-runner → Validate data integrity
+6. Monitor costs and performance
+```
+
+**BigQuery Best Practices** (Context7: /websites/cloud_google-bigquery):
+```sql
+-- Partition by date, cluster by filter columns
+CREATE TABLE analytics.events (
+  event_id INT64,
+  event_timestamp TIMESTAMP,
+  user_id STRING,
+  event_type STRING
+)
+PARTITION BY DATE(event_timestamp)
+CLUSTER BY user_id, event_type
+OPTIONS (
+  partition_expiration_days=365,
+  require_partition_filter=TRUE
+);
+
+-- Optimize queries with partition pruning
+SELECT event_type, COUNT(*) as total
+FROM analytics.events
+WHERE DATE(event_timestamp) BETWEEN '2024-01-01' AND '2024-01-31'
+  AND user_id = 'user123'
+GROUP BY event_type;
+```
+
+**Cosmos DB Best Practices** (Context7: /websites/learn_microsoft-en-us-azure-cosmos-db):
+- Choose partition key for even distribution (avoid hot partitions)
+- Use Session consistency for most scenarios
+- Implement TTL for automatic data cleanup
+- Monitor and optimize RU/s consumption
+
+## 4. CACHE IMPLEMENTATION PIPELINE
+
+**Trigger**: Redis caching requirement
+**Sequence**:
+
+```
+1. redis-expert → Design cache strategy
+2. Query Context7 for caching patterns
+3. Implement cache invalidation logic
+4. Write cache hit/miss tests
+5. test-runner → Verify cache behavior
+6. Monitor memory usage and hit rates
+```
+
+**Redis Caching Patterns** (Context7: /websites/redis_io):
+```redis
+# Client-side caching with placeholder pattern
+SET cache:user:1234 "caching-in-progress"
+# Compute expensive operation
+SET cache:user:1234 "{\"name\":\"Alice\",\"role\":\"admin\"}"
+EXPIRE cache:user:1234 3600
+
+# Cache aside pattern
+GET cache:product:456
+# If miss, query database and set cache
+SET cache:product:456 '{"name":"Widget","price":29.99}'
+EXPIRE cache:product:456 1800
+```
+
+**Cache Invalidation Strategies**:
+- **Write-through**: Update cache immediately on write
+- **Write-behind**: Queue writes, update cache async
+- **TTL-based**: Set expiration on all cached items
+- **Event-based**: Invalidate on database change events
+
+## 5. DATABASE BACKUP PIPELINE
+
+**Trigger**: Backup strategy implementation
+**Sequence**:
+
+```
+1. Database expert → Design backup strategy
+2. Query Context7 for backup best practices
+3. Implement automated backup script
+4. Write restore verification test
+5. test-runner → Test backup and restore
+6. Document recovery procedures
+7. Schedule regular backup drills
+```
+
+**Backup Strategies by Database**:
+
+### PostgreSQL
+```bash
+# Full backup with custom format (allows selective restore)
+pg_dump -Fc -d mydatabase -f backup.dump
+
+# Point-in-time recovery setup
+# Enable WAL archiving in postgresql.conf
+wal_level = replica
+archive_mode = on
+archive_command = 'cp %p /backup/wal/%f'
+```
+
+### MongoDB
+```bash
+# Consistent backup with oplog
+mongodump --oplog --gzip --out /backup/mongodb/
+
+# Verify backup integrity
+mongorestore --dry-run --gzip --dir /backup/mongodb/
+```
+
+### Redis
+```bash
+# Manual snapshot
+redis-cli BGSAVE
+
+# Configure automatic snapshots
+save 900 1      # After 900s if ≥1 key changed
+save 300 10     # After 300s if ≥10 keys changed
+save 60 10000   # After 60s if ≥10000 keys changed
+```
+
+### BigQuery
+```sql
+-- Create snapshot for time travel
+CREATE SNAPSHOT TABLE mydataset.events_snapshot
+CLONE mydataset.events;
+
+-- Query historical data (up to 7 days)
+SELECT * FROM mydataset.events
+FOR SYSTEM_TIME AS OF TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 1 DAY);
+```
+
+### Cosmos DB
+- Automatic continuous backups with configurable retention
+- Manual backup triggers for critical operations
+- Cross-region geo-redundant backups
+
+## 6. INDEX MANAGEMENT PIPELINE
+
+**Trigger**: New query patterns or performance degradation
+**Sequence**:
+
+```
+1. Database expert → Analyze query patterns
+2. Query Context7 for indexing strategies
+3. Identify missing or unused indexes
+4. Create index with minimal lock strategy
+5. test-runner → Verify performance improvement
+6. Monitor index usage statistics
+```
+
+**PostgreSQL Index Management** (Context7: /websites/postgresql):
+```sql
+-- Create index concurrently (no table lock)
+CREATE INDEX CONCURRENTLY idx_users_created_at ON users(created_at);
+
+-- Identify unused indexes
+SELECT
+  schemaname, tablename, indexname, idx_scan
+FROM pg_stat_user_indexes
+WHERE idx_scan = 0 AND schemaname = 'public'
+ORDER BY pg_relation_size(indexrelid) DESC;
+
+-- Drop unused index
+DROP INDEX CONCURRENTLY idx_old_unused;
+```
+
+**MongoDB Index Management** (Context7: /mongodb/docs):
+```javascript
+// Find index inconsistencies in sharded collections
+db.collection.aggregate([
+  {$indexStats: {}},
+  {$group: {
+    _id: "$name",
+    shards: {$push: "$shard"},
+    specs: {$push: {$objectToArray: {$ifNull: ["$spec", {}]}}}
+  }},
+  {$project: {
+    missingFromShards: {$setDifference: ["$allShards", "$shards"]}
+  }}
+]);
+```
+
+## Pipeline Requirements
+
+### NEVER ALLOWED
+
+- ❌ Running migrations without backups
+- ❌ Deploying unindexed queries to production
+- ❌ Skipping rollback plan creation
+- ❌ Ignoring query performance analysis
+- ❌ Using SELECT * in production code
+- ❌ Creating indexes without CONCURRENTLY (PostgreSQL)
+- ❌ Modifying production schemas without testing
+
+### ALWAYS REQUIRED
+
+- ✅ Test migrations on dev first
+- ✅ EXPLAIN ANALYZE for new queries
+- ✅ Monitor query performance continuously
+- ✅ Document schema changes in changelog
+- ✅ Verify backup restoration regularly
+- ✅ Use Context7 for best practice validation
+- ✅ Implement connection pooling
+- ✅ Set query timeouts
+- ✅ Monitor database metrics
+
+## Success Metrics
+
+### Performance
+- Query response time < 100ms for OLTP
+- Query response time < 5s for OLAP
+- Index hit ratio > 95% (PostgreSQL)
+- Cache hit rate > 80% (Redis)
+
+### Reliability
+- Zero data loss during migrations
+- Successful backup restoration test (monthly)
+- Migration rollback success rate = 100%
+- Replication lag < 1s
+
+### Cost Optimization
+- BigQuery: Queries stay within budget
+- Cosmos DB: RU/s utilization 70-85%
+- Unused index removal (quarterly review)
+- Storage growth within projections
+
+## Context7 Integration
+
+All database operations should query Context7 for:
+- Latest best practices for specific database versions
+- Performance optimization techniques
+- Security hardening guidelines
+- Disaster recovery procedures
+
+Example Context7 queries:
+- `/websites/postgresql` - PostgreSQL indexing and optimization
+- `/mongodb/docs` - MongoDB aggregation and sharding
+- `/websites/redis_io` - Redis data structures and caching
+- `/websites/cloud_google-bigquery` - BigQuery partitioning and clustering
+- `/websites/learn_microsoft-en-us-azure-cosmos-db` - Cosmos DB consistency and partitioning