moai-adk 0.32.8__py3-none-any.whl → 0.41.2__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-platform-baas/scripts/provider-selector.py

@@ -1,323 +0,0 @@
-#!/usr/bin/env python3
-"""
-BaaS Provider Selection Tool
-
-AI-powered provider selection based on project requirements.
-Integrates with Context7 for latest provider documentation.
-"""
-
-import asyncio
-import re
-import sys
-from typing import Any, Dict
-
-
-class BaaSProviderSelector:
-    """AI-powered BaaS provider selection engine."""
-
-    def __init__(self):
-        self.auth_providers = {
-            "auth0": {
-                "strengths": ["enterprise_sso", "b2b_saas", "50_connections"],
-                "cost_tier": "enterprise",
-                "use_cases": ["enterprise", "b2b", "large_teams"],
-            },
-            "clerk": {
-                "strengths": ["webauthn", "modern_ui", "organizations"],
-                "cost_tier": "mid_tier",
-                "use_cases": ["modern_apps", "startups", "user_experience"],
-            },
-            "firebase_auth": {
-                "strengths": ["google_integration", "mobile_first", "analytics"],
-                "cost_tier": "pay_as_you_go",
-                "use_cases": ["mobile_apps", "google_ecosystem", "startups"],
-            },
-        }
-
-        self.database_providers = {
-            "supabase": {
-                "strengths": ["postgresql_16", "realtime", "rls"],
-                "cost_tier": "mid_tier",
-                "use_cases": ["complex_apps", "multi_tenant", "realtime_features"],
-            },
-            "neon": {
-                "strengths": ["serverless", "auto_scaling", "branching"],
-                "cost_tier": "pay_as_you_go",
-                "use_cases": ["serverless_apps", "development", "cost_optimization"],
-            },
-            "convex": {
-                "strengths": ["realtime_backend", "reactive", "optimistic_updates"],
-                "cost_tier": "mid_tier",
-                "use_cases": [
-                    "collaborative_apps",
-                    "realtime_features",
-                    "typescript_apps",
-                ],
-            },
-            "firestore": {
-                "strengths": ["mobile_sync", "offline_support", "google_integration"],
-                "cost_tier": "pay_as_you_go",
-                "use_cases": ["mobile_apps", "offline_first", "google_ecosystem"],
-            },
-        }
-
-        self.deployment_providers = {
-            "vercel": {
-                "strengths": ["edge_deployment", "nextjs_optimization", "global_cdn"],
-                "cost_tier": "mid_tier",
-                "use_cases": ["jamstack", "nextjs_apps", "global_performance"],
-            },
-            "railway": {
-                "strengths": ["containers", "full_stack", "multi_region"],
-                "cost_tier": "mid_tier",
-                "use_cases": ["containers", "complex_backends", "multi_region"],
-            },
-        }
-
-    def parse_budget(self, budget_str: str) -> int:
-        """Parse budget string and return numeric value."""
-        if not budget_str:
-            return 1000  # Default budget
-
-        # Extract numbers from budget string
-        match = re.search(r"\$?(\d+)", budget_str)
-        if match:
-            return int(match.group(1))
-        return 1000  # Default if no number found
-
-    def analyze_requirements(self, requirements: Dict[str, Any]) -> Dict[str, float]:
-        """Analyze project requirements and return weighted scores."""
-
-        scores = {
-            "enterprise_needs": 0.0,
-            "realtime_required": 0.0,
-            "mobile_first": 0.0,
-            "cost_sensitivity": 0.0,
-            "performance_critical": 0.0,
-            "multi_tenant": 0.0,
-            "development_speed": 0.0,
-            "global_users": 0.0,
-        }
-
-        # Analyze requirements
-        if "enterprise" in requirements.get("requirements", []):
-            scores["enterprise_needs"] = 1.0
-
-        if "real-time" in requirements.get("requirements", []):
-            scores["realtime_required"] = 1.0
-
-        if "mobile" in requirements.get("tech_stack", "").lower():
-            scores["mobile_first"] = 0.8
-
-        # Parse budget for cost sensitivity
-        budget = self.parse_budget(requirements.get("budget", ""))
-        if budget < 300:
-            scores["cost_sensitivity"] = 1.0
-        elif budget < 500:
-            scores["cost_sensitivity"] = 0.5
-
-        if "performance" in requirements.get("requirements", []):
-            scores["performance_critical"] = 0.8
-
-        if "scalable" in requirements.get("requirements", []):
-            scores["multi_tenant"] = 0.6
-
-        if requirements.get("team_size", 0) < 5:
-            scores["development_speed"] = 0.8
-
-        if "global" in requirements.get("requirements", []):
-            scores["global_users"] = 1.0
-
-        return scores
-
-    def score_auth_provider(self, provider: str, scores: Dict[str, float]) -> float:
-        """Score authentication provider against requirements."""
-        score = 0.0
-
-        # Enterprise needs scoring
-        if scores["enterprise_needs"] > 0.5:
-            if provider == "auth0":
-                score += 3.0
-            elif provider == "clerk":
-                score += 1.0
-            else:
-                score += 0.5
-
-        # Development speed scoring
-        if scores["development_speed"] > 0.5:
-            if provider == "clerk":
-                score += 2.0
-            elif provider == "firebase_auth":
-                score += 1.5
-            else:
-                score += 1.0
-
-        # Mobile first scoring
-        if scores["mobile_first"] > 0.5:
-            if provider == "firebase_auth":
-                score += 2.5
-            elif provider == "clerk":
-                score += 1.5
-            else:
-                score += 1.0
-
-        # Cost sensitivity scoring
-        if scores["cost_sensitivity"] > 0.5:
-            if provider in ["clerk", "firebase_auth"]:
-                score += 1.5
-            else:
-                score += 0.5
-
-        return score
-
-    def score_database_provider(self, provider: str, scores: Dict[str, float]) -> float:
-        """Score database provider against requirements."""
-        score = 0.0
-
-        # Real-time requirements scoring
-        if scores["realtime_required"] > 0.5:
-            if provider in ["supabase", "convex"]:
-                score += 3.0
-            elif provider == "firestore":
-                score += 2.0
-            else:
-                score += 1.0
-
-        # Cost sensitivity scoring
-        if scores["cost_sensitivity"] > 0.5:
-            if provider in ["neon", "firestore"]:
-                score += 2.0
-            else:
-                score += 1.0
-
-        # Multi-tenant scoring
-        if scores["multi_tenant"] > 0.5:
-            if provider == "supabase":
-                score += 3.0
-            elif provider in ["neon", "convex"]:
-                score += 2.0
-            else:
-                score += 1.0
-
-        # Development speed scoring
-        if scores["development_speed"] > 0.5:
-            if provider == "supabase":
-                score += 2.0
-            elif provider == "convex":
-                score += 1.5
-            else:
-                score += 1.0
-
-        return score
-
-    def score_deployment_provider(self, provider: str, scores: Dict[str, float]) -> float:
-        """Score deployment provider against requirements."""
-        score = 0.0
-
-        # Performance critical scoring
-        if scores["performance_critical"] > 0.5:
-            if provider == "vercel":
-                score += 3.0
-            else:
-                score += 2.0
-
-        # Global users scoring
-        if scores["global_users"] > 0.5:
-            if provider == "vercel":
-                score += 3.0
-            else:
-                score += 2.0
-
-        # Development speed scoring
-        if scores["development_speed"] > 0.5:
-            if provider == "vercel":
-                score += 2.0
-            else:
-                score += 1.5
-
-        # Complex backend scoring
-        if scores["multi_tenant"] > 0.5:
-            if provider == "railway":
-                score += 2.5
-            else:
-                score += 1.5
-
-        return score
-
-    def select_providers(self, requirements: Dict[str, Any]) -> Dict[str, str]:
-        """Select optimal providers based on requirements."""
-
-        scores = self.analyze_requirements(requirements)
-
-        # Score all providers
-        auth_scores = {provider: self.score_auth_provider(provider, scores) for provider in self.auth_providers}
-
-        db_scores = {provider: self.score_database_provider(provider, scores) for provider in self.database_providers}
-
-        deploy_scores = {
-            provider: self.score_deployment_provider(provider, scores) for provider in self.deployment_providers
-        }
-
-        # Select top providers
-        recommendation = {
-            "authentication": max(auth_scores, key=auth_scores.get),
-            "database": max(db_scores, key=db_scores.get),
-            "deployment": max(deploy_scores, key=deploy_scores.get),
-        }
-
-        return {
-            "recommendation": recommendation,
-            "scores": {
-                "authentication": auth_scores,
-                "database": db_scores,
-                "deployment": deploy_scores,
-            },
-            "requirement_analysis": scores,
-        }
-
-
-async def main():
-    """Main function to run provider selection."""
-
-    if len(sys.argv) < 2:
-        print("Usage: python provider-selector.py <json_requirements>")
-        print(
-            "Example: python provider-selector.py "
-            '\'{"requirements": ["scalable", "real-time"], '
-            '"tech_stack": "Next.js", "team_size": 5, "budget": "$500/month"}\''
-        )
-        sys.exit(1)
-
-    try:
-        import json
-
-        requirements = json.loads(sys.argv[1])
-
-        selector = BaaSProviderSelector()
-        result = selector.select_providers(requirements)
-
-        print("=== BaaS Provider Recommendation ===")
-        print(f"Authentication: {result['recommendation']['authentication']}")
-        print(f"Database: {result['recommendation']['database']}")
-        print(f"Deployment: {result['recommendation']['deployment']}")
-
-        print("\n=== Detailed Scores ===")
-        print("Authentication Scores:")
-        for provider, score in result["scores"]["authentication"].items():
-            print(f"  {provider}: {score:.1f}")
-
-        print("\nDatabase Scores:")
-        for provider, score in result["scores"]["database"].items():
-            print(f"  {provider}: {score:.1f}")
-
-        print("\nDeployment Scores:")
-        for provider, score in result["scores"]["deployment"].items():
-            print(f"  {provider}: {score:.1f}")
-
-    except Exception as e:
-        print(f"Error: {e}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

moai_adk/templates/.claude/skills/moai-platform-baas/templates/stack-config.yaml

@@ -1,204 +0,0 @@
-# BaaS Stack Configuration Template
-# Template for configuring unified BaaS provider stack
-
-project:
-  name: "my-project"
-  description: "Project description"
-  framework: "nextjs"  # nextjs, react, vue, angular, express, flask, etc.
-  
-# Provider Selection Configuration
-providers:
-  authentication:
-    # Options: auth0, clerk, firebase_auth
-    selected: "clerk"
-    config:
-      # Clerk Configuration
-      clerk:
-        publishable_key: "${CLERK_PUBLISHABLE_KEY}"
-        secret_key: "${CLERK_SECRET_KEY}"
-        webhook_secret: "${CLERK_WEBHOOK_SECRET}"
-        features:
-          - "social_auth"
-          - "mfa"
-          - "organizations"
-          - "webauthn"
-      
-      # Auth0 Configuration  
-      auth0:
-        domain: "${AUTH0_DOMAIN}"
-        client_id: "${AUTH0_CLIENT_ID}"
-        client_secret: "${AUTH0_CLIENT_SECRET}"
-        management_token: "${AUTH0_MANAGEMENT_TOKEN}"
-        features:
-          - "enterprise_sso"
-          - "organizations"
-          - "b2b_saas"
-      
-      # Firebase Auth Configuration
-      firebase_auth:
-        api_key: "${FIREBASE_API_KEY}"
-        auth_domain: "${FIREBASE_AUTH_DOMAIN}"
-        project_id: "${FIREBASE_PROJECT_ID}"
-        features:
-          - "google_integration"
-          - "mobile_first"
-          - "analytics"
-
-  database:
-    # Options: supabase, neon, convex, firestore
-    selected: "supabase"
-    config:
-      # Supabase Configuration
-      supabase:
-        url: "${SUPABASE_URL}"
-        anon_key: "${SUPABASE_ANON_KEY}"
-        service_key: "${SUPABASE_SERVICE_KEY}"
-        features:
-          - "postgresql_16"
-          - "row_level_security"
-          - "realtime_subscriptions"
-          - "edge_functions"
-      
-      # Neon Configuration
-      neon:
-        connection_string: "${NEON_CONNECTION_STRING}"
-        api_key: "${NEON_API_KEY}"
-        project_id: "${NEON_PROJECT_ID}"
-        features:
-          - "serverless"
-          - "auto_scaling"
-          - "instant_branches"
-          - "30_day_pitr"
-      
-      # Convex Configuration
-      convex:
-        url: "${CONVEX_URL}"
-        websocket_url: "${CONVEX_WEBSOCKET_URL}"
-        features:
-          - "realtime_backend"
-          - "reactive_queries"
-          - "optimistic_updates"
-          - "database_branching"
-      
-      # Firestore Configuration
-      firestore:
-        project_id: "${FIRESTORE_PROJECT_ID}"
-        credentials_file: "${FIRESTORE_CREDENTIALS_FILE}"
-        features:
-          - "mobile_sync"
-          - "offline_support"
-          - "google_integration"
-
-  deployment:
-    # Options: vercel, railway
-    selected: "vercel"
-    config:
-      # Vercel Configuration
-      vercel:
-        org_id: "${VERCEL_ORG_ID}"
-        project_id: "${VERCEL_PROJECT_ID}"
-        access_token: "${VERCEL_ACCESS_TOKEN}"
-        features:
-          - "edge_deployment"
-          - "nextjs_optimization"
-          - "global_cdn"
-          - "analytics"
-      
-      # Railway Configuration
-      railway:
-        api_token: "${RAILWAY_API_TOKEN}"
-        project_id: "${RAILWAY_PROJECT_ID}"
-        features:
-          - "containers"
-          - "full_stack"
-          - "multi_region"
-          - "ci_cd"
-
-# Cross-Provider Integration Settings
-integration:
-  # Environment variables that will be set across all providers
-  global_environment:
-    NODE_ENV: "production"
-    NEXT_PUBLIC_APP_NAME: "${PROJECT_NAME}"
-    
-  # Provider-specific integrations
-  webhooks:
-    clerk_to_convex:
-      enabled: true
-      events: ["user.created", "user.updated", "organization.created"]
-    
-    auth0_to_supabase:
-      enabled: true
-      events: ["user.created", "user.updated", "organization.created"]
-
-# Cost Optimization Settings
-cost_optimization:
-  # Enable cost monitoring and optimization
-  monitoring: true
-  
-  # Provider-specific optimization settings
-  database_optimization:
-    connection_pooling: true
-    read_replicas: false  # Enable for high traffic
-    auto_scaling: true
-    
-  deployment_optimization:
-    edge_caching: true
-    cdn_optimization: true
-    bundle_optimization: true
-
-# Security and Compliance Settings
-security:
-  # Compliance requirements
-  compliance: ["GDPR"]  # Add HIPAA, SOC2, etc. as needed
-  
-  # Security features
-  features:
-    encryption_at_rest: true
-    encryption_in_transit: true
-    audit_logging: true
-    session_timeout: "30_minutes"
-    
-  # Provider-specific security
-  auth_security:
-    mfa_required: true
-    password_policy: "strong"
-    session_management: true
-    
-  database_security:
-    row_level_security: true
-    backup_encryption: true
-    access_controls: true
-
-# Monitoring and Analytics
-monitoring:
-  # Enable monitoring across providers
-  enabled: true
-  
-  # Metrics to track
-  metrics:
-    - "user_growth"
-    - "database_usage"
-    - "deployment_performance"
-    - "cost_tracking"
-    
-  # Analytics providers
-  analytics:
-    firebase_analytics: true
-    vercel_analytics: true
-    custom_dashboards: true
-
-# Development and Testing Settings
-development:
-  # Local development configuration
-  local_environment:
-    database: "local_postgresql"
-    authentication: "local_clerk"
-    deployment: "local_vercel"
-    
-  # Testing configuration
-  testing:
-    test_database: "test_supabase"
-    test_authentication: "test_clerk"
-    integration_tests: true
-    e2e_tests: true