django-cfg 1.3.9__py3-none-any.whl → 1.3.11__py3-none-any.whl

django_cfg/management/commands/app_agent_generate.py

@@ -1,342 +0,0 @@
-"""
-Django management command for AI-powered app generation.
-
-This command serves as a thin wrapper that:
-1. Loads django-cfg configuration
-2. Delegates to django_app_agent module
-3. Provides Django-native CLI interface
-"""
-
-import asyncio
-import sys
-from pathlib import Path
-from typing import List, Optional
-
-from django.core.management.base import BaseCommand, CommandError
-from django.conf import settings
-
-try:
-    from django_cfg.modules.django_app_agent.services.base import create_service_dependencies
-    from django_cfg.modules.django_app_agent.ui.cli import DjangoAppAgentCLI
-    from django_cfg.modules.django_app_agent.models.requests import (
-        AppGenerationRequest,
-        AppFeature,
-        AppComplexity,
-        AppType
-    )
-    from django_cfg.modules.django_app_agent.models.enums import AppFeature as AppFeatureEnum
-    from django_cfg.modules.django_app_agent.core.exceptions import DjangoAppAgentError
-    from django_cfg.modules.django_app_agent.core.config import AgentConfig
-    from django_cfg.modules.django_app_agent.utils.logging import get_logger
-except ImportError as e:
-    print(f"Error importing django_app_agent module: {e}")
-    print("Make sure the django_app_agent module is properly installed.")
-    sys.exit(1)
-
-
-class Command(BaseCommand):
-    """Django management command for AI-powered app generation."""
-    
-    help = "Generate Django applications using AI assistance (Django App Agent)"
-    
-    def add_arguments(self, parser):
-        """Add command line arguments."""
-        
-        # Positional arguments
-        parser.add_argument(
-            'app_name',
-            nargs='?',
-            type=str,
-            help='Name of the application to generate'
-        )
-        
-        parser.add_argument(
-            'description',
-            nargs='?',
-            type=str,
-            help='Description of the application'
-        )
-        
-        # Optional arguments
-        parser.add_argument(
-            '--features',
-            type=str,
-            help='Comma-separated list of features (e.g., models,admin,views,api,tests)'
-        )
-        
-        parser.add_argument(
-            '--complexity',
-            choices=['simple', 'moderate', 'advanced', 'enterprise'],
-            default='moderate',
-            help='Application complexity level (default: moderate)'
-        )
-        
-        parser.add_argument(
-            '--app-type',
-            choices=['django', 'django_cfg'],
-            default='django_cfg',
-            help='Type of application to generate (default: django_cfg)'
-        )
-        
-        parser.add_argument(
-            '--output-dir',
-            type=str,
-            help='Custom output directory for the application'
-        )
-        
-        parser.add_argument(
-            '--max-questions',
-            type=int,
-            default=20,
-            help='Maximum number of interactive questions (default: 20)'
-        )
-        
-        parser.add_argument(
-            '--no-questions',
-            action='store_true',
-            help='Skip interactive questioning'
-        )
-        
-        parser.add_argument(
-            '--interactive',
-            action='store_true',
-            default=True,
-            help='Enable interactive mode (default: True)'
-        )
-        
-        parser.add_argument(
-            '--non-interactive',
-            action='store_true',
-            help='Disable interactive mode'
-        )
-        
-        parser.add_argument(
-            '--quality-threshold',
-            type=float,
-            default=0.8,
-            help='Quality threshold for generated code (0.0-1.0, default: 0.8)'
-        )
-        
-        parser.add_argument(
-            '--model',
-            type=str,
-            help='Specific AI model to use (e.g., gpt-4o, claude-3-5-sonnet)'
-        )
-        
-        parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Enable verbose output'
-        )
-    
-    def handle(self, *args, **options):
-        """Handle the command execution."""
-        
-        try:
-            # Initialize logger
-            logger = get_logger("management.commands.generate_app")
-            
-            # Determine interactive mode
-            interactive = options.get('interactive', True) and not options.get('non_interactive', False)
-            if options.get('no_questions'):
-                interactive = False
-            
-            # If no arguments provided and interactive mode, use CLI
-            if not options.get('app_name') and interactive:
-                self.stdout.write(
-                    self.style.SUCCESS("🚀 Starting Django App Agent CLI...")
-                )
-                return self._run_interactive_cli(options)
-            
-            # Validate required arguments for non-interactive mode
-            if not options.get('app_name'):
-                raise CommandError("app_name is required when not in interactive mode")
-            
-            if not options.get('description'):
-                raise CommandError("description is required when not in interactive mode")
-            
-            # Parse features
-            features = []
-            if options.get('features'):
-                feature_names = [f.strip() for f in options['features'].split(',')]
-                for feature_name in feature_names:
-                    try:
-                        features.append(AppFeatureEnum(feature_name.lower()))
-                    except ValueError:
-                        self.stdout.write(
-                            self.style.WARNING(f"Unknown feature: {feature_name}")
-                        )
-            
-            # Create generation request
-            request = AppGenerationRequest(
-                app_name=options['app_name'],
-                description=options['description'],
-                app_type=AppType(options.get('app_type', 'django_cfg')),
-                complexity=AppComplexity(options.get('complexity', 'moderate')),
-                features=features,
-                output_directory=options.get('output_dir'),
-                max_questions=options.get('max_questions', 20),
-                rich_interface=interactive,
-                verbose_output=options.get('verbose', False)
-            )
-            
-            # Run generation
-            return self._run_generation(request, options)
-            
-        except DjangoAppAgentError as e:
-            logger.error(f"App generation failed: {e}")
-            raise CommandError(f"App generation failed: {e}")
-        except Exception as e:
-            logger.error(f"Unexpected error: {e}")
-            raise CommandError(f"Unexpected error: {e}")
-    
-    def _run_interactive_cli(self, options):
-        """Run the interactive CLI interface."""
-        try:
-            # Initialize CLI
-            cli = DjangoAppAgentCLI()
-            
-            # Run async CLI
-            if sys.platform == 'win32':
-                asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
-            
-            result = asyncio.run(cli.run_interactive())
-            
-            if result and result.status == "success":
-                self.stdout.write(
-                    self.style.SUCCESS(
-                        f"✅ Application '{result.app_name}' generated successfully!"
-                    )
-                )
-                self.stdout.write(f"Generated {len(result.generated_files)} files")
-                if result.report_path:
-                    self.stdout.write(f"Report saved to: {result.report_path}")
-            else:
-                self.stdout.write(
-                    self.style.ERROR("❌ Application generation failed")
-                )
-                if result and result.errors:
-                    for error in result.errors:
-                        self.stdout.write(f"  • {error}")
-                        
-        except KeyboardInterrupt:
-            self.stdout.write("\n🛑 Generation cancelled by user")
-        except Exception as e:
-            raise CommandError(f"CLI execution failed: {e}")
-    
-    def _run_generation(self, request: AppGenerationRequest, options):
-        """Run the generation process."""
-        try:
-            # Initialize configuration from django-cfg
-            config = AgentConfig.from_django_cfg()
-            logger = get_logger("management.commands.generate_app")
-            
-            # Import and initialize services
-            from django_cfg.modules.django_app_agent.services import AppGeneratorService
-            from django_cfg.modules.django_app_agent.agents import AgentRegistry, AgentClientFactory
-            
-            # Set up agent registry
-            registry = AgentRegistry()
-            
-            # For now, we'll use a placeholder since actual agents aren't implemented yet
-            # In production, this would initialize real agents
-            local_client = {}  # AgentClientFactory.create_local_client(agents, config, logger)
-            # Note: Using placeholder since actual agents aren't implemented yet
-            # registry.register_agent("local", local_client, "client")
-            
-            # Initialize service
-            service = AppGeneratorService(config)
-            
-            # Create service dependencies
-            
-            dependencies = create_service_dependencies(
-                config=config,
-                service_name="app_generator",
-                project_root=Path.cwd(),
-                output_directory=Path.cwd() / "apps"
-            )
-            
-            # Show progress
-            self.stdout.write(f"🔧 Generating application '{request.app_name}'...")
-            self.stdout.write(f"   Type: {request.app_type.value}")
-            self.stdout.write(f"   Complexity: {request.complexity.value}")
-            self.stdout.write(f"   Features: {', '.join([f.value for f in request.features])}")
-            
-            # Run generation (async)
-            if sys.platform == 'win32':
-                asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
-            
-            result = asyncio.run(service.process(request, dependencies))
-            
-            # Display results
-            if result.success:
-                self.stdout.write(
-                    self.style.SUCCESS(
-                        f"✅ Application '{request.app_name}' generated successfully!"
-                    )
-                )
-                self.stdout.write(f"Generated {len(result.generated_files)} files")
-                
-                if options.get('verbose'):
-                    self.stdout.write("\n📁 Generated files:")
-                    for file in result.generated_files:
-                        self.stdout.write(f"  • {file.relative_path}")
-                
-                if result.generation_report_path:
-                    self.stdout.write(f"📊 Report saved to: {result.generation_report_path}")
-                    
-                self.stdout.write(f"📈 Quality score: {result.quality_score:.2f}")
-                self.stdout.write(f"🔒 Type safety: {result.type_safety_score:.2f}")
-                self.stdout.write(f"📏 Pattern consistency: {result.pattern_consistency_score:.2f}")
-                self.stdout.write(f"🧪 Test coverage: {result.test_coverage_percentage:.1f}%")
-            else:
-                self.stdout.write(
-                    self.style.ERROR(f"❌ Generation failed")
-                )
-                if result.errors:
-                    for error in result.errors:
-                        self.stdout.write(f"  • {error.message}")
-                        
-        except Exception as e:
-            raise CommandError(f"Generation process failed: {e}")
-    
-    def _show_help(self):
-        """Show extended help information."""
-        help_text = """
-🚀 Django App Agent - AI-Powered Application Generation
-
-USAGE:
-    python manage.py app_agent_generate [APP_NAME] [DESCRIPTION] [OPTIONS]
-
-EXAMPLES:
-    # Interactive mode (recommended)
-    python manage.py app_agent_generate
-    
-    # Direct generation
-    python manage.py app_agent_generate blog "A simple blog application"
-    
-    # With specific features
-    python manage.py app_agent_generate shop "E-commerce shop" --features models,admin,api,tests
-    
-    # Advanced configuration
-    python manage.py app_agent_generate cms "Content management" \\
-        --complexity advanced \\
-        --app-type django_cfg \\
-        --max-questions 15 \\
-        --verbose
-
-FEATURES:
-    Available features: models, views, urls, admin, forms, templates, static,
-    api, serializers, viewsets, filters, pagination, tests, fixtures,
-    security, authentication, permissions, tasks, signals, middleware,
-    management_commands, docs, services, cfg_config, cfg_modules
-
-COMPLEXITY LEVELS:
-    simple     - Basic CRUD with minimal features
-    moderate   - Standard app with common features  
-    advanced   - Full-featured app with API and tests
-    enterprise - Complete app with security and advanced features
-
-For more information, visit: https://docs.django-cfg.com/app-agent/
-        """
-        self.stdout.write(help_text)

django_cfg/management/commands/app_agent_info.py

@@ -1,308 +0,0 @@
-"""
-Django management command for Django App Agent information.
-
-This command provides information about the Django App Agent module,
-its capabilities, configuration, and available commands.
-"""
-
-import sys
-from pathlib import Path
-
-from django.core.management.base import BaseCommand, CommandError
-from django.conf import settings
-
-try:
-    from django_cfg.modules.django_app_agent.core.config import AgentConfig
-    from django_cfg.modules.django_app_agent.utils.logging import get_logger
-    from django_cfg.modules.django_app_agent.models.enums import AppFeature, AppComplexity, AppType
-    from django_cfg.modules.django_app_agent import __version__
-except ImportError as e:
-    print(f"Error importing django_app_agent module: {e}")
-    print("Make sure the django_app_agent module is properly installed.")
-    sys.exit(1)
-
-
-class Command(BaseCommand):
-    """Django management command for Django App Agent information."""
-    
-    help = "Show information about Django App Agent module and its capabilities"
-    
-    def add_arguments(self, parser):
-        """Add command line arguments."""
-        
-        parser.add_argument(
-            '--features',
-            action='store_true',
-            help='Show available application features'
-        )
-        
-        parser.add_argument(
-            '--config',
-            action='store_true',
-            help='Show current configuration'
-        )
-        
-        parser.add_argument(
-            '--commands',
-            action='store_true',
-            help='Show available app_agent commands'
-        )
-        
-        parser.add_argument(
-            '--examples',
-            action='store_true',
-            help='Show usage examples'
-        )
-        
-        parser.add_argument(
-            '--all',
-            action='store_true',
-            help='Show all information'
-        )
-    
-    def handle(self, *args, **options):
-        """Handle the command execution."""
-        
-        try:
-            # Show header
-            self._show_header()
-            
-            # Determine what to show
-            show_all = options.get('all', False)
-            
-            if show_all or not any([
-                options.get('features'),
-                options.get('config'),
-                options.get('commands'),
-                options.get('examples')
-            ]):
-                # Show everything if no specific options or --all
-                self._show_overview()
-                self._show_features()
-                self._show_commands()
-                self._show_config()
-                self._show_examples()
-            else:
-                # Show specific sections
-                if options.get('features') or show_all:
-                    self._show_features()
-                
-                if options.get('config') or show_all:
-                    self._show_config()
-                
-                if options.get('commands') or show_all:
-                    self._show_commands()
-                
-                if options.get('examples') or show_all:
-                    self._show_examples()
-            
-            # Show footer
-            self._show_footer()
-            
-        except Exception as e:
-            raise CommandError(f"Failed to show information: {e}")
-    
-    def _show_header(self):
-        """Show header information."""
-        self.stdout.write(
-            self.style.SUCCESS("🤖 Django App Agent - AI-Powered Application Generation")
-        )
-        self.stdout.write("=" * 70)
-        
-        try:
-            version = __version__
-        except:
-            version = "Unknown"
-        
-        self.stdout.write(f"Version: {version}")
-        self.stdout.write(f"Project: {getattr(settings, 'BASE_DIR', 'Unknown')}")
-        self.stdout.write("")
-    
-    def _show_overview(self):
-        """Show module overview."""
-        self.stdout.write(self.style.HTTP_INFO("📋 Overview"))
-        self.stdout.write("-" * 20)
-        
-        overview = """
-Django App Agent is an AI-powered module for generating Django applications
-with intelligent questioning, context analysis, and code generation capabilities.
-
-Key Features:
-• 🎯 Interactive AI-driven app generation
-• 🧠 Intelligent questioning system
-• 🏗️ Multiple application types (Django, Django-CFG)
-• 📊 Quality validation and reporting
-• 🎨 Rich terminal interface
-• 🔧 Extensible architecture with agent isolation
-
-The module supports 25+ application features and can generate everything
-from simple CRUD apps to complex enterprise applications with APIs,
-authentication, and advanced functionality.
-        """
-        
-        self.stdout.write(overview.strip())
-        self.stdout.write("")
-    
-    def _show_features(self):
-        """Show available application features."""
-        self.stdout.write(self.style.HTTP_INFO("🎯 Available Application Features"))
-        self.stdout.write("-" * 40)
-        
-        # Group features by category
-        feature_groups = {
-            "Core Django": [
-                AppFeature.MODELS, AppFeature.VIEWS, AppFeature.URLS,
-                AppFeature.ADMIN, AppFeature.FORMS, AppFeature.TEMPLATES, AppFeature.STATIC
-            ],
-            "API & Serialization": [
-                AppFeature.API, AppFeature.SERIALIZERS, AppFeature.VIEWSETS,
-                AppFeature.FILTERS, AppFeature.PAGINATION
-            ],
-            "Testing & Quality": [
-                AppFeature.TESTS, AppFeature.FIXTURES
-            ],
-            "Background Processing": [
-                AppFeature.TASKS, AppFeature.SIGNALS
-            ],
-            "Security & Auth": [
-                AppFeature.SECURITY, AppFeature.AUTHENTICATION, AppFeature.PERMISSIONS
-            ],
-            "Configuration & Management": [
-                AppFeature.CONFIG, AppFeature.MANAGEMENT_COMMANDS,
-                AppFeature.MIDDLEWARE, AppFeature.CONTEXT_PROCESSORS
-            ],
-            "Database": [
-                AppFeature.MIGRATIONS, AppFeature.ROUTERS
-            ],
-            "Documentation": [
-                AppFeature.DOCS, AppFeature.SERVICES
-            ],
-            "Django-CFG Specific": [
-                AppFeature.CFG_CONFIG, AppFeature.CFG_MODULES
-            ]
-        }
-        
-        for group_name, features in feature_groups.items():
-            self.stdout.write(f"\n{group_name}:")
-            for feature in features:
-                self.stdout.write(f"  • {feature.value}")
-        
-        self.stdout.write(f"\nTotal: {len(list(AppFeature))} features available")
-        self.stdout.write("")
-    
-    def _show_commands(self):
-        """Show available app_agent commands."""
-        self.stdout.write(self.style.HTTP_INFO("💻 Available Commands"))
-        self.stdout.write("-" * 25)
-        
-        commands = [
-            {
-                'name': 'app_agent_generate',
-                'description': 'Generate Django applications with AI assistance',
-                'usage': 'python manage.py app_agent_generate [app_name] [description] [options]'
-            },
-            {
-                'name': 'app_agent_diagnose',
-                'description': 'Diagnose problems in Django/Django-cfg projects',
-                'usage': 'python manage.py app_agent_diagnose [options]'
-            },
-            {
-                'name': 'app_agent_info',
-                'description': 'Show information about Django App Agent (this command)',
-                'usage': 'python manage.py app_agent_info [options]'
-            }
-        ]
-        
-        for cmd in commands:
-            self.stdout.write(f"\n🔧 {cmd['name']}")
-            self.stdout.write(f"   {cmd['description']}")
-            self.stdout.write(f"   Usage: {cmd['usage']}")
-        
-        self.stdout.write("")
-    
-    def _show_config(self):
-        """Show current configuration."""
-        self.stdout.write(self.style.HTTP_INFO("⚙️ Configuration"))
-        self.stdout.write("-" * 20)
-        
-        try:
-            config = AgentConfig()
-            
-            self.stdout.write("Configuration Status: ✅ Loaded")
-            
-            # Show complexity levels
-            self.stdout.write(f"\nComplexity Levels:")
-            for complexity in AppComplexity:
-                features = complexity.get_recommended_features()
-                time_est = complexity.get_estimated_time_minutes()
-                max_questions = complexity.get_max_questions()
-                
-                self.stdout.write(f"  • {complexity.value}:")
-                self.stdout.write(f"    - Features: {len(features)}")
-                self.stdout.write(f"    - Est. time: {time_est} minutes")
-                self.stdout.write(f"    - Max questions: {max_questions}")
-            
-            # Show app types
-            self.stdout.write(f"\nApplication Types:")
-            for app_type in AppType:
-                self.stdout.write(f"  • {app_type.value}")
-            
-        except Exception as e:
-            self.stdout.write(f"Configuration Status: ❌ Error loading config: {e}")
-        
-        self.stdout.write("")
-    
-    def _show_examples(self):
-        """Show usage examples."""
-        self.stdout.write(self.style.HTTP_INFO("📚 Usage Examples"))
-        self.stdout.write("-" * 25)
-        
-        examples = [
-            {
-                'title': 'Interactive Generation (Recommended)',
-                'command': 'python manage.py app_agent_generate',
-                'description': 'Start interactive mode with AI questioning'
-            },
-            {
-                'title': 'Quick Blog App',
-                'command': 'python manage.py app_agent_generate blog "A simple blog application"',
-                'description': 'Generate a blog app with default settings'
-            },
-            {
-                'title': 'E-commerce with Specific Features',
-                'command': 'python manage.py app_agent_generate shop "E-commerce shop" --features models,admin,api,tests --complexity advanced',
-                'description': 'Generate advanced e-commerce app with specific features'
-            },
-            {
-                'title': 'Django-CFG Module',
-                'command': 'python manage.py app_agent_generate analytics "Analytics module" --app-type django_cfg --complexity enterprise',
-                'description': 'Generate enterprise-level django-cfg module'
-            },
-            {
-                'title': 'Project Diagnosis',
-                'command': 'python manage.py app_agent_diagnose',
-                'description': 'Interactive diagnosis of project issues'
-            },
-            {
-                'title': 'Specific App Diagnosis',
-                'command': 'python manage.py app_agent_diagnose --app users --category auth --description "Login issues"',
-                'description': 'Diagnose authentication issues in users app'
-            }
-        ]
-        
-        for example in examples:
-            self.stdout.write(f"\n📝 {example['title']}")
-            self.stdout.write(f"   Command: {example['command']}")
-            self.stdout.write(f"   Description: {example['description']}")
-        
-        self.stdout.write("")
-    
-    def _show_footer(self):
-        """Show footer information."""
-        self.stdout.write("=" * 70)
-        self.stdout.write("For more information:")
-        self.stdout.write("• Documentation: https://docs.django-cfg.com/app-agent/")
-        self.stdout.write("• Help: python manage.py app_agent_generate --help")
-        self.stdout.write("• Help: python manage.py app_agent_diagnose --help")
-        self.stdout.write("")
-        self.stdout.write("🚀 Ready to generate amazing Django applications with AI!")