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

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

@@ -1,133 +0,0 @@
-"""
-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

@@ -1,40 +0,0 @@
-"""
-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

@@ -1,202 +0,0 @@
-"""
-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

@@ -1,316 +0,0 @@
-"""
-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