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

django_cfg/modules/django_app_agent/services/app_generator/ai_integration.py

@@ -0,0 +1,133 @@
+"""
+AI Integration Module for Django App Agent Generation.
+
+This module handles integration with AI agents for intelligent
+code generation based on user requirements and project context.
+"""
+
+from typing import List, Dict, Any
+from pathlib import Path
+
+from ..base import ServiceDependencies
+from ...core.config import AgentConfig
+from ...models.responses import GeneratedFile
+from ...models.enums import AppFeature, FileType
+from ...agents.generation.app_generator import AppGeneratorAgent, FileGenerationRequest
+from .context import GenerationContext
+
+
+class AIGenerationManager:
+    """Manages AI-powered code generation process."""
+    
+    def __init__(self, config: AgentConfig):
+        """Initialize AI generation manager."""
+        self.config = config
+    
+    async def run_ai_generation(
+        self,
+        context: GenerationContext,
+        dependencies: ServiceDependencies
+    ) -> None:
+        """Run AI agents for intelligent code generation."""
+        dependencies.log_operation("Running AI generation agents")
+        
+        try:
+            # Create AI agent
+            print("🔍 Creating AI agent with config...")
+            print(f"🔍 Config type: {type(self.config)}")
+            try:
+                ai_agent = AppGeneratorAgent(self.config)
+                print("✅ AI agent created successfully")
+            except Exception as e:
+                print(f"❌ Failed to create AI agent: {e}")
+                print(f"❌ Exception type: {type(e)}")
+                import traceback
+                print(f"❌ Traceback: {traceback.format_exc()}")
+                raise
+            
+            # Generate files for each requested feature using AI
+            generated_files = []
+            for feature in context.request.features:
+                try:
+                    # Create request for this feature
+                    file_request = FileGenerationRequest(
+                        app_name=context.request.app_name,
+                        description=context.request.description,
+                        feature=feature,
+                        app_type=context.request.app_type,
+                        complexity=context.request.complexity
+                    )
+                    
+                    # Generate file using AI
+                    ai_response = await ai_agent.generate_file(file_request)
+                    
+                    # Create file path
+                    file_path = context.app_directory / ai_response.filename
+                    
+                    # Create generated file record
+                    generated_file = GeneratedFile(
+                        relative_path=str(file_path.relative_to(context.target_directory)),
+                        absolute_path=file_path,
+                        content=ai_response.content,
+                        line_count=len(ai_response.content.split('\n')),
+                        file_type=self._get_file_type(ai_response.filename),
+                        type_safety_score=8.5,  # AI-generated files typically have good type safety
+                        complexity_score=6.0,  # AI-generated files can be moderately complex
+                        description=ai_response.description
+                    )
+                    
+                    # Write file to disk
+                    file_path.parent.mkdir(parents=True, exist_ok=True)
+                    file_path.write_text(ai_response.content)
+                    
+                    # Add to context
+                    context.add_generated_file(generated_file)
+                    generated_files.append(ai_response)
+                    
+                    dependencies.log_operation(f"Generated {feature.value} file", filename=ai_response.filename)
+                    
+                except Exception as e:
+                    dependencies.log_error(f"Failed to generate {feature.value} with AI", e)
+                    # Continue with other features
+                    continue
+            
+            # Record AI generation results
+            context.agent_outputs["generation"] = {
+                "status": "completed",
+                "message": f"AI generation completed successfully for {len(generated_files)} features",
+                "ai_files_count": len(generated_files),
+                "features_generated": [gf.filename for gf in generated_files],
+                "recommendations": [f"Generated {gf.filename} for {context.request.app_name}" for gf in generated_files]
+            }
+            
+        except Exception as e:
+            dependencies.log_error("AI generation failed", e)
+            context.agent_outputs["generation"] = {
+                "status": "error",
+                "message": f"Agent communication failed: {e}",
+                "recommendations": []
+            }
+    
+    def _get_file_type(self, filename: str) -> FileType:
+        """Determine file type from filename."""
+        # Map specific Django files to their types
+        if filename == "__init__.py":
+            return FileType.INIT
+        elif filename == "models.py":
+            return FileType.MODEL
+        elif filename == "views.py":
+            return FileType.VIEW
+        elif filename == "admin.py":
+            return FileType.ADMIN
+        elif filename == "urls.py":
+            return FileType.URL
+        elif filename == "forms.py":
+            return FileType.FORM
+        elif filename == "tests.py":
+            return FileType.TEST
+        elif filename.endswith('.html'):
+            return FileType.TEMPLATE
+        elif filename.endswith('.py'):
+            return FileType.CONFIG  # Default for other Python files
+        else:
+            return FileType.CONFIG  # Default fallback

django_cfg/modules/django_app_agent/services/app_generator/context.py

@@ -0,0 +1,40 @@
+"""
+Generation Context for Django App Agent Module.
+
+This module contains the GenerationContext class that manages state
+and data throughout the application generation process.
+"""
+
+from typing import List, Dict, Any
+from pathlib import Path
+
+from pydantic import BaseModel, Field, ConfigDict
+
+from ...models.requests import AppGenerationRequest
+from ...models.responses import GeneratedFile
+
+
+class GenerationContext(BaseModel):
+    """Context for application generation process."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    request: AppGenerationRequest = Field(description="Original generation request")
+    target_directory: Path = Field(description="Target directory for generated app")
+    template_variables: Dict[str, Any] = Field(default_factory=dict, description="Template variables")
+    generated_files: List[GeneratedFile] = Field(default_factory=list, description="Generated files")
+    validation_results: Dict[str, Any] = Field(default_factory=dict, description="Validation results")
+    agent_outputs: Dict[str, Any] = Field(default_factory=dict, description="AI agent outputs")
+    
+    @property
+    def app_directory(self) -> Path:
+        """Get the application directory path."""
+        return self.target_directory / self.request.app_name
+    
+    def add_generated_file(self, file: GeneratedFile) -> None:
+        """Add a generated file to the context."""
+        self.generated_files.append(file)
+    
+    def get_files_by_type(self, file_type: str) -> List[GeneratedFile]:
+        """Get generated files by type."""
+        return [f for f in self.generated_files if f.file_type == file_type]

django_cfg/modules/django_app_agent/services/app_generator/main.py

@@ -0,0 +1,202 @@
+"""
+Main Application Generator Service for Django App Agent Module.
+
+This service orchestrates the complete application generation process,
+coordinating validation, structure creation, AI generation, and quality validation.
+"""
+
+from typing import Dict, Any
+from pathlib import Path
+from datetime import datetime, timezone
+import uuid
+
+from ..base import BaseService, ServiceDependencies
+from ...models.requests import AppGenerationRequest
+from ...models.responses import AppGenerationResult, QualityMetrics, ValidationIssue
+from ...models.enums import ValidationSeverity
+from ...core.config import AgentConfig
+
+from .context import GenerationContext
+from .validation import GenerationValidator
+from .structure import StructureGenerator
+from .ai_integration import AIGenerationManager
+
+
+class AppGeneratorService(BaseService[AppGenerationRequest, AppGenerationResult]):
+    """
+    Main service for generating Django applications with AI assistance.
+    
+    This service coordinates the entire generation process:
+    1. Validation of requirements and compatibility
+    2. Basic structure creation
+    3. AI-powered code generation
+    4. Quality validation and metrics calculation
+    """
+    
+    def __init__(self, config: AgentConfig):
+        """Initialize the application generator service."""
+        super().__init__("app_generator", config)
+        self.config = config
+        
+        # Initialize sub-components
+        self.validator = GenerationValidator()
+        self.structure_generator = StructureGenerator()
+        self.ai_manager = AIGenerationManager(config)
+    
+    async def process(
+        self, 
+        request: AppGenerationRequest, 
+        dependencies: ServiceDependencies
+    ) -> AppGenerationResult:
+        """
+        Process application generation request.
+        
+        Args:
+            request: Application generation request
+            dependencies: Service dependencies for logging and operations
+            
+        Returns:
+            AppGenerationResult with generation details and metrics
+        """
+        start_time = datetime.now(timezone.utc)
+        generation_id = str(uuid.uuid4())
+        
+        try:
+            dependencies.log_operation(
+                f"Starting application generation for '{request.app_name}'",
+                app_name=request.app_name,
+                app_type=request.app_type.value,
+                features=[f.value for f in request.features]
+            )
+            
+            # Create generation context
+            context = await self._create_generation_context(request, dependencies)
+            
+            # Validate generation requirements
+            await self.validator.validate_generation_requirements(context, dependencies)
+            
+            # Generate basic app structure
+            await self.structure_generator.generate_app_structure(context, dependencies)
+            
+            # Generate feature files using templates (fallback)
+            await self.structure_generator.generate_feature_files(context, dependencies)
+            
+            # Run AI agents for intelligent code generation
+            await self.ai_manager.run_ai_generation(context, dependencies)
+            
+            # Validate generated code
+            quality_metrics = await self.validator.validate_generated_code(context, dependencies)
+            
+            # Calculate execution time
+            end_time = datetime.now(timezone.utc)
+            execution_time = (end_time - start_time).total_seconds()
+            
+            # Extract AI dialogue for reporting
+            ai_dialogue = self._extract_ai_dialogue(context)
+            
+            # Create successful result
+            return AppGenerationResult(
+                app_name=request.app_name,
+                generation_id=generation_id,
+                success=True,
+                total_execution_time_seconds=execution_time,
+                files_count=len(context.generated_files),
+                lines_of_code=sum(len(f.content.splitlines()) for f in context.generated_files),
+                quality_score=quality_metrics.overall_score,
+                type_safety_score=quality_metrics.type_safety_score,
+                pattern_consistency_score=quality_metrics.pattern_consistency,
+                test_coverage_percentage=quality_metrics.test_coverage,
+                integration_successful=True,
+                generated_files=context.generated_files,
+                patterns_followed=["django_best_practices", "pep8", "type_hints"],
+                dependencies_resolved=["django", "django_cfg"],
+                errors=[],
+                warnings=[],
+                report_directory=context.target_directory / request.app_name / "@report",
+                generation_report_path=context.target_directory / request.app_name / "@report" / "generation_report.md"
+            )
+            
+        except Exception as e:
+            # Calculate execution time even on failure
+            end_time = datetime.now(timezone.utc)
+            execution_time = (end_time - start_time).total_seconds()
+            
+            # Create error result
+            error_message = str(e)
+            if len(error_message) > 500:
+                error_message = error_message[:497] + "..."
+            
+            error_issue = ValidationIssue(
+                file_path="generation_process",
+                line_number=1,
+                severity=ValidationSeverity.ERROR,
+                message=error_message,
+                rule_id="generation_error"
+            )
+            
+            return AppGenerationResult(
+                app_name=request.app_name if 'request' in locals() else "unknown",
+                generation_id=generation_id,
+                success=False,
+                total_execution_time_seconds=execution_time,
+                files_count=0,
+                lines_of_code=0,
+                quality_score=0.0,
+                type_safety_score=0.0,
+                pattern_consistency_score=0.0,
+                test_coverage_percentage=0.0,
+                integration_successful=False,
+                generated_files=[],
+                patterns_followed=[],
+                dependencies_resolved=[],
+                errors=[error_issue],
+                warnings=[],
+                report_directory=Path("/tmp"),
+                generation_report_path=Path("/tmp/error.md")
+            )
+    
+    async def _create_generation_context(
+        self,
+        request: AppGenerationRequest,
+        dependencies: ServiceDependencies
+    ) -> GenerationContext:
+        """Create generation context from request."""
+        # Determine target directory
+        if request.output_directory:
+            target_directory = Path(request.output_directory)
+        else:
+            target_directory = Path.cwd() / "apps"
+        
+        # Create template variables
+        template_variables = {
+            "app_name": request.app_name,
+            "description": request.description,
+            "app_type": request.app_type.value,
+            "complexity": request.complexity.value,
+            "features": [f.value for f in request.features],
+            "timestamp": datetime.now(timezone.utc).isoformat()
+        }
+        
+        return GenerationContext(
+            request=request,
+            target_directory=target_directory,
+            template_variables=template_variables
+        )
+    
+    def _extract_ai_dialogue(self, context: GenerationContext) -> list[Dict[str, Any]]:
+        """Extract AI dialogue from generation context."""
+        dialogue = []
+        
+        # Extract from agent outputs
+        generation_output = context.agent_outputs.get("generation", {})
+        if generation_output:
+            dialogue.append({
+                "agent": "generation_agent",
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "message": generation_output.get("message", ""),
+                "status": generation_output.get("status", "unknown"),
+                "files_generated": generation_output.get("ai_files_count", 0),
+                "recommendations": generation_output.get("recommendations", [])
+            })
+        
+        return dialogue

django_cfg/modules/django_app_agent/services/app_generator/structure.py

@@ -0,0 +1,316 @@
+"""
+Structure Generator for Django App Agent Module.
+
+This module handles creation of basic application structure
+and feature-specific files using templates.
+"""
+
+from typing import Dict, List
+from pathlib import Path
+
+from ..base import ServiceDependencies
+from ...core.exceptions import FileSystemError
+from ...models.responses import GeneratedFile
+from ...models.enums import AppFeature, FileType
+from .context import GenerationContext
+
+
+class StructureGenerator:
+    """Handles generation of application structure and files."""
+    
+    def __init__(self):
+        """Initialize structure generator with feature file mappings."""
+        self.feature_files: Dict[AppFeature, List[str]] = {
+            AppFeature.MODELS: ["models.py"],
+            AppFeature.VIEWS: ["views.py"],
+            AppFeature.URLS: ["urls.py"],
+            AppFeature.ADMIN: ["admin.py"],
+            AppFeature.FORMS: ["forms.py"],
+            AppFeature.TESTS: ["tests.py"],
+            AppFeature.API: ["serializers.py", "viewsets.py"],
+            AppFeature.SERIALIZERS: ["serializers.py"],
+            AppFeature.VIEWSETS: ["viewsets.py"],
+            AppFeature.FILTERS: ["filters.py"],
+            AppFeature.PAGINATION: ["pagination.py"],
+            AppFeature.SECURITY: ["security.py"],
+            AppFeature.AUTHENTICATION: ["authentication.py"],
+            AppFeature.TASKS: ["tasks.py"],
+            AppFeature.DOCS: ["docs.py"],
+            AppFeature.SERVICES: ["services/"],
+            AppFeature.CFG_CONFIG: ["config.py"],
+            AppFeature.CFG_MODULES: ["modules/"],
+        }
+    
+    async def generate_app_structure(
+        self,
+        context: GenerationContext,
+        dependencies: ServiceDependencies
+    ) -> None:
+        """Generate basic application directory structure."""
+        try:
+            # Create app directory
+            context.app_directory.mkdir(parents=True, exist_ok=True)
+            
+            # Create basic structure
+            basic_dirs = ["migrations", "templates", "static", "tests"]
+            for dir_name in basic_dirs:
+                (context.app_directory / dir_name).mkdir(exist_ok=True)
+            
+            # Create __init__.py
+            init_file = context.app_directory / "__init__.py"
+            init_content = f'"""Django app: {context.request.app_name}"""'
+            
+            generated_file = GeneratedFile(
+                relative_path=str(init_file.relative_to(context.target_directory)),
+                absolute_path=init_file,
+                content=init_content,
+                line_count=len(init_content.split('\n')),
+                file_type=FileType.INIT,
+                type_safety_score=8.0,
+                complexity_score=2.0,  # Simple __init__.py file
+                description="Application initialization file"
+            )
+            
+            init_file.write_text(init_content)
+            context.add_generated_file(generated_file)
+            
+        except Exception as e:
+            raise FileSystemError(
+                f"Failed to create app structure: {e}",
+                file_path=str(context.app_directory),
+                operation="create_app_structure"
+            )
+    
+    async def generate_feature_files(
+        self,
+        context: GenerationContext,
+        dependencies: ServiceDependencies
+    ) -> None:
+        """Generate files for requested features."""
+        for feature in context.request.features:
+            await self.generate_feature(feature, context, dependencies)
+    
+    async def generate_feature(
+        self,
+        feature: AppFeature,
+        context: GenerationContext,
+        dependencies: ServiceDependencies
+    ) -> None:
+        """Generate files for a specific feature."""
+        files_to_create = self.feature_files.get(feature, [])
+        
+        for file_pattern in files_to_create:
+            if file_pattern.endswith("/"):
+                # Directory
+                dir_path = context.app_directory / file_pattern.rstrip("/")
+                dir_path.mkdir(parents=True, exist_ok=True)
+            else:
+                # File
+                await self.generate_feature_file(feature, file_pattern, context, dependencies)
+    
+    async def generate_feature_file(
+        self,
+        feature: AppFeature,
+        filename: str,
+        context: GenerationContext,
+        dependencies: ServiceDependencies
+    ) -> None:
+        """Generate a specific feature file."""
+        file_path = context.app_directory / filename
+        
+        # Generate basic template content
+        content = self.get_template_content(feature, filename, context)
+        
+        # Create generated file record
+        generated_file = GeneratedFile(
+            relative_path=str(file_path.relative_to(context.target_directory)),
+            absolute_path=file_path,
+            content=content,
+            line_count=len(content.split('\n')),
+            file_type=self.get_file_type(filename),
+            type_safety_score=7.0,  # Default score for generated files
+            complexity_score=5.0,  # Moderate complexity for feature files
+            description=f"{feature.value} implementation file"
+        )
+        
+        # Write file
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        file_path.write_text(content)
+        
+        context.add_generated_file(generated_file)
+    
+    def get_template_content(
+        self,
+        feature: AppFeature,
+        filename: str,
+        context: GenerationContext
+    ) -> str:
+        """Get template content for a feature file."""
+        app_name = context.request.app_name
+        description = context.request.description
+        
+        templates = {
+            "models.py": f'''"""
+Models for {app_name} application.
+
+{description}
+"""
+
+from django.db import models
+
+
+class {app_name.title().replace('_', '')}Model(models.Model):
+    """Main model for {app_name} application."""
+    
+    name = models.CharField(max_length=100, help_text="Name of the item")
+    description = models.TextField(blank=True, help_text="Description of the item")
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    
+    class Meta:
+        verbose_name = "{app_name.replace('_', ' ').title()}"
+        verbose_name_plural = "{app_name.replace('_', ' ').title()}s"
+        ordering = ['-created_at']
+    
+    def __str__(self):
+        return self.name
+''',
+            "views.py": f'''"""
+Views for {app_name} application.
+
+{description}
+"""
+
+from django.shortcuts import render
+from django.views.generic import ListView, DetailView
+
+
+class {app_name.title().replace('_', '')}ListView(ListView):
+    """List view for {app_name} items."""
+    
+    template_name = '{app_name}/list.html'
+    context_object_name = 'items'
+    paginate_by = 10
+
+
+class {app_name.title().replace('_', '')}DetailView(DetailView):
+    """Detail view for {app_name} items."""
+    
+    template_name = '{app_name}/detail.html'
+    context_object_name = 'item'
+''',
+            "urls.py": f'''"""
+URL configuration for {app_name} application.
+
+{description}
+"""
+
+from django.urls import path
+from . import views
+
+app_name = '{app_name}'
+
+urlpatterns = [
+    path('', views.{app_name.title().replace('_', '')}ListView.as_view(), name='list'),
+    path('<int:pk>/', views.{app_name.title().replace('_', '')}DetailView.as_view(), name='detail'),
+]
+''',
+            "admin.py": f'''"""
+Admin configuration for {app_name} application.
+
+{description}
+"""
+
+from django.contrib import admin
+from .models import {app_name.title().replace('_', '')}Model
+
+
+@admin.register({app_name.title().replace('_', '')}Model)
+class {app_name.title().replace('_', '')}Admin(admin.ModelAdmin):
+    """Admin interface for {app_name} model."""
+    
+    list_display = ['name', 'created_at', 'updated_at']
+    list_filter = ['created_at', 'updated_at']
+    search_fields = ['name', 'description']
+    readonly_fields = ['created_at', 'updated_at']
+''',
+            "forms.py": f'''"""
+Forms for {app_name} application.
+
+{description}
+"""
+
+from django import forms
+from .models import {app_name.title().replace('_', '')}Model
+
+
+class {app_name.title().replace('_', '')}Form(forms.ModelForm):
+    """Form for {app_name} model."""
+    
+    class Meta:
+        model = {app_name.title().replace('_', '')}Model
+        fields = ['name', 'description']
+        widgets = {{
+            'description': forms.Textarea(attrs={{'rows': 4}}),
+        }}
+''',
+            "tests.py": f'''"""
+Tests for {app_name} application.
+
+{description}
+"""
+
+from django.test import TestCase
+from .models import {app_name.title().replace('_', '')}Model
+
+
+class {app_name.title().replace('_', '')}TestCase(TestCase):
+    """Test cases for {app_name} application."""
+    
+    def test_placeholder(self):
+        """Placeholder test."""
+        self.assertTrue(True)
+''',
+            "apps.py": f'''"""
+App configuration for {app_name}.
+
+{description}
+"""
+
+from django.apps import AppConfig
+
+
+class {app_name.title().replace('_', '')}Config(AppConfig):
+    """Configuration for {app_name} application."""
+    
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = '{app_name}'
+    verbose_name = '{app_name.replace("_", " ").title()}'
+'''
+        }
+        
+        return templates.get(filename, f"# {filename} for {app_name}\n# Generated by Django App Agent\n")
+    
+    def get_file_type(self, filename: str) -> FileType:
+        """Determine file type from filename."""
+        # Map specific Django files to their types
+        if filename == "__init__.py":
+            return FileType.INIT
+        elif filename == "models.py":
+            return FileType.MODEL
+        elif filename == "views.py":
+            return FileType.VIEW
+        elif filename == "admin.py":
+            return FileType.ADMIN
+        elif filename == "urls.py":
+            return FileType.URL
+        elif filename == "forms.py":
+            return FileType.FORM
+        elif filename == "tests.py":
+            return FileType.TEST
+        elif filename.endswith('.html'):
+            return FileType.TEMPLATE
+        elif filename.endswith('.py'):
+            return FileType.CONFIG  # Default for other Python files
+        else:
+            return FileType.CONFIG  # Default fallback