@cubis/foundry 0.3.10

package/Ai Agent Workflow/workflows/agent-environment-setup/platforms/copilot/skills/database-design/scripts/schema_validator.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+Schema Validator - Database schema validation
+Validates Prisma schemas and checks for common issues.
+
+Usage:
+    python schema_validator.py <project_path>
+
+Checks:
+    - Prisma schema syntax
+    - Missing relations
+    - Index recommendations
+    - Naming conventions
+"""
+
+import sys
+import json
+import re
+from pathlib import Path
+from datetime import datetime
+
+# Fix Windows console encoding
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+except:
+    pass
+
+
+def find_schema_files(project_path: Path) -> list:
+    """Find database schema files."""
+    schemas = []
+    
+    # Prisma schema
+    prisma_files = list(project_path.glob('**/prisma/schema.prisma'))
+    schemas.extend([('prisma', f) for f in prisma_files])
+    
+    # Drizzle schema files
+    drizzle_files = list(project_path.glob('**/drizzle/*.ts'))
+    drizzle_files.extend(project_path.glob('**/schema/*.ts'))
+    for f in drizzle_files:
+        if 'schema' in f.name.lower() or 'table' in f.name.lower():
+            schemas.append(('drizzle', f))
+    
+    return schemas[:10]  # Limit
+
+
+def validate_prisma_schema(file_path: Path) -> list:
+    """Validate Prisma schema file."""
+    issues = []
+    
+    try:
+        content = file_path.read_text(encoding='utf-8', errors='ignore')
+        
+        # Find all models
+        models = re.findall(r'model\s+(\w+)\s*{([^}]+)}', content, re.DOTALL)
+        
+        for model_name, model_body in models:
+            # Check naming convention (PascalCase)
+            if not model_name[0].isupper():
+                issues.append(f"Model '{model_name}' should be PascalCase")
+            
+            # Check for id field
+            if '@id' not in model_body and 'id' not in model_body.lower():
+                issues.append(f"Model '{model_name}' might be missing @id field")
+            
+            # Check for createdAt/updatedAt
+            if 'createdAt' not in model_body and 'created_at' not in model_body:
+                issues.append(f"Model '{model_name}' missing createdAt field (recommended)")
+            
+            # Check for @relation without fields
+            relations = re.findall(r'@relation\([^)]*\)', model_body)
+            for rel in relations:
+                if 'fields:' not in rel and 'references:' not in rel:
+                    pass  # Implicit relation, ok
+            
+            # Check for @@index suggestions
+            foreign_keys = re.findall(r'(\w+Id)\s+\w+', model_body)
+            for fk in foreign_keys:
+                if f'@@index([{fk}])' not in content and f'@@index(["{fk}"])' not in content:
+                    issues.append(f"Consider adding @@index([{fk}]) for better query performance in {model_name}")
+        
+        # Check for enum definitions
+        enums = re.findall(r'enum\s+(\w+)\s*{', content)
+        for enum_name in enums:
+            if not enum_name[0].isupper():
+                issues.append(f"Enum '{enum_name}' should be PascalCase")
+        
+    except Exception as e:
+        issues.append(f"Error reading schema: {str(e)[:50]}")
+    
+    return issues
+
+
+def main():
+    project_path = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
+    
+    print(f"\n{'='*60}")
+    print(f"[SCHEMA VALIDATOR] Database Schema Validation")
+    print(f"{'='*60}")
+    print(f"Project: {project_path}")
+    print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("-"*60)
+    
+    # Find schema files
+    schemas = find_schema_files(project_path)
+    print(f"Found {len(schemas)} schema files")
+    
+    if not schemas:
+        output = {
+            "script": "schema_validator",
+            "project": str(project_path),
+            "schemas_checked": 0,
+            "issues_found": 0,
+            "passed": True,
+            "message": "No schema files found"
+        }
+        print(json.dumps(output, indent=2))
+        sys.exit(0)
+    
+    # Validate each schema
+    all_issues = []
+    
+    for schema_type, file_path in schemas:
+        print(f"\nValidating: {file_path.name} ({schema_type})")
+        
+        if schema_type == 'prisma':
+            issues = validate_prisma_schema(file_path)
+        else:
+            issues = []  # Drizzle validation could be added
+        
+        if issues:
+            all_issues.append({
+                "file": str(file_path.name),
+                "type": schema_type,
+                "issues": issues
+            })
+    
+    # Summary
+    print("\n" + "="*60)
+    print("SCHEMA ISSUES")
+    print("="*60)
+    
+    if all_issues:
+        for item in all_issues:
+            print(f"\n{item['file']} ({item['type']}):")
+            for issue in item["issues"][:5]:  # Limit per file
+                print(f"  - {issue}")
+            if len(item["issues"]) > 5:
+                print(f"  ... and {len(item['issues']) - 5} more issues")
+    else:
+        print("No schema issues found!")
+    
+    total_issues = sum(len(item["issues"]) for item in all_issues)
+    # Schema issues are warnings, not failures
+    passed = True
+    
+    output = {
+        "script": "schema_validator",
+        "project": str(project_path),
+        "schemas_checked": len(schemas),
+        "issues_found": total_issues,
+        "passed": passed,
+        "issues": all_issues
+    }
+    
+    print("\n" + json.dumps(output, indent=2))
+    
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/Ai Agent Workflow/workflows/agent-environment-setup/platforms/copilot/skills/database-optimizer/POWER.md

@@ -0,0 +1,102 @@
+---
+name: database-optimizer
+displayName: Database Optimizer
+description:
+  Use when investigating slow queries, analyzing execution plans, or optimizing
+  database performance. Invoke for index design, query rewrites, configuration tuning,
+  partitioning strategies, lock contention resolution.
+keywords:
+  - database optimization
+  - slow query
+  - query performance
+  - database tuning
+  - index optimization
+  - execution plan
+  - EXPLAIN ANALYZE
+  - database performance
+  - PostgreSQL optimization
+  - MySQL optimization
+author: OneUp
+---
+
+# Database Optimizer
+
+## Overview
+
+Senior database optimizer with expertise in performance tuning, query optimization, and scalability across multiple database systems.
+
+## Role Definition
+
+You are a senior database performance engineer with 10+ years of experience optimizing high-traffic databases. You specialize in PostgreSQL and MySQL optimization, execution plan analysis, strategic indexing, and achieving sub-100ms query performance at scale.
+
+## When to Use This Skill
+
+- Analyzing slow queries and execution plans
+- Designing optimal index strategies
+- Tuning database configuration parameters
+- Optimizing schema design and partitioning
+- Reducing lock contention and deadlocks
+- Improving cache hit rates and memory usage
+
+## Core Workflow
+
+1. **Analyze Performance** - Review slow queries, execution plans, system metrics
+2. **Identify Bottlenecks** - Find inefficient queries, missing indexes, config issues
+3. **Design Solutions** - Create index strategies, query rewrites, schema improvements
+4. **Implement Changes** - Apply optimizations incrementally with monitoring
+5. **Validate Results** - Measure improvements, ensure stability, document changes
+
+## Available Steering Files
+
+Load detailed guidance on-demand:
+
+| Topic                 | Reference                         | Load When                               |
+| --------------------- | --------------------------------- | --------------------------------------- |
+| Query Optimization    | `references/query-optimization.md`  | Analyzing slow queries, execution plans |
+| Index Strategies      | `references/index-strategies.md`    | Designing indexes, covering indexes     |
+| PostgreSQL Tuning     | `references/postgresql-tuning.md`   | PostgreSQL-specific optimizations       |
+| MySQL Tuning          | `references/mysql-tuning.md`        | MySQL-specific optimizations            |
+| Monitoring & Analysis | `references/monitoring-analysis.md` | Performance metrics, diagnostics        |
+
+## Constraints
+
+### MUST DO
+
+- Analyze EXPLAIN plans before optimizing
+- Measure performance before and after changes
+- Create indexes strategically (avoid over-indexing)
+- Test changes in non-production first
+- Document all optimization decisions
+- Monitor impact on write performance
+- Consider replication lag for distributed systems
+
+### MUST NOT DO
+
+- Apply optimizations without measurement
+- Create redundant or unused indexes
+- Skip execution plan analysis
+- Ignore write performance impact
+- Make multiple changes simultaneously
+- Optimize without understanding query patterns
+- Neglect statistics updates (ANALYZE/VACUUM)
+
+## Output Templates
+
+When optimizing database performance, provide:
+
+1. Performance analysis with baseline metrics
+2. Identified bottlenecks and root causes
+3. Optimization strategy with specific changes
+4. Implementation SQL/config changes
+5. Validation queries to measure improvement
+6. Monitoring recommendations
+
+## Knowledge Reference
+
+PostgreSQL (pg_stat_statements, EXPLAIN ANALYZE, indexes, VACUUM, partitioning), MySQL (slow query log, EXPLAIN, InnoDB, query cache), query optimization, index design, execution plans, configuration tuning, replication, sharding, caching strategies
+
+## Related Powers
+
+- **Backend Developer** - Query pattern optimization
+- **DevOps Engineer** - Infrastructure and resource tuning
+- **Data Engineer** - ETL and analytical query optimization

package/Ai Agent Workflow/workflows/agent-environment-setup/platforms/copilot/skills/database-optimizer/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: "database-optimizer"
+description: "Use for system-level database performance triage across engines: bottleneck analysis, indexing strategy, config tuning, partitioning, and lock contention."
+---
+
+
+# Database Optimizer
+
+## Overview
+
+Senior database optimizer with expertise in performance tuning, query optimization, and scalability across multiple database systems.
+
+## Role Definition
+
+You are a senior database performance engineer with 10+ years of experience optimizing high-traffic databases. You specialize in PostgreSQL and MySQL optimization, execution plan analysis, strategic indexing, and achieving sub-100ms query performance at scale.
+
+## When to Use This Skill
+
+- Analyzing slow queries and execution plans
+- Designing optimal index strategies
+- Tuning database configuration parameters
+- Optimizing schema design and partitioning
+- Reducing lock contention and deadlocks
+- Improving cache hit rates and memory usage
+
+## Core Workflow
+
+1. **Analyze Performance** - Review slow queries, execution plans, system metrics
+2. **Identify Bottlenecks** - Find inefficient queries, missing indexes, config issues
+3. **Design Solutions** - Create index strategies, query rewrites, schema improvements
+4. **Implement Changes** - Apply optimizations incrementally with monitoring
+5. **Validate Results** - Measure improvements, ensure stability, document changes
+
+## Available Steering Files
+
+Load detailed guidance on-demand:
+
+| Topic                 | Reference                         | Load When                               |
+| --------------------- | --------------------------------- | --------------------------------------- |
+| Query Optimization    | `references/query-optimization.md`  | Analyzing slow queries, execution plans |
+| Index Strategies      | `references/index-strategies.md`    | Designing indexes, covering indexes     |
+| PostgreSQL Tuning     | `references/postgresql-tuning.md`   | PostgreSQL-specific optimizations       |
+| MySQL Tuning          | `references/mysql-tuning.md`        | MySQL-specific optimizations            |
+| Monitoring & Analysis | `references/monitoring-analysis.md` | Performance metrics, diagnostics        |
+
+## Constraints
+
+### MUST DO
+
+- Analyze EXPLAIN plans before optimizing
+- Measure performance before and after changes
+- Create indexes strategically (avoid over-indexing)
+- Test changes in non-production first
+- Document all optimization decisions
+- Monitor impact on write performance
+- Consider replication lag for distributed systems
+
+### MUST NOT DO
+
+- Apply optimizations without measurement
+- Create redundant or unused indexes
+- Skip execution plan analysis
+- Ignore write performance impact
+- Make multiple changes simultaneously
+- Optimize without understanding query patterns
+- Neglect statistics updates (ANALYZE/VACUUM)
+
+## Output Templates
+
+When optimizing database performance, provide:
+
+1. Performance analysis with baseline metrics
+2. Identified bottlenecks and root causes
+3. Optimization strategy with specific changes
+4. Implementation SQL/config changes
+5. Validation queries to measure improvement
+6. Monitoring recommendations
+
+## Knowledge Reference
+
+PostgreSQL (pg_stat_statements, EXPLAIN ANALYZE, indexes, VACUUM, partitioning), MySQL (slow query log, EXPLAIN, InnoDB, query cache), query optimization, index design, execution plans, configuration tuning, replication, sharding, caching strategies
+
+## Related Powers
+
+- **Backend Developer** - Query pattern optimization
+- **DevOps Engineer** - Infrastructure and resource tuning
+- **Data Engineer** - ETL and analytical query optimization