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

django_cfg/modules/django_app_agent/services/context_builder/code_extractor.py

@@ -1,141 +0,0 @@
-"""
-Code Extraction Module for Context Builder.
-
-This module handles extraction of relevant code samples
-and examples from existing project files.
-"""
-
-from typing import Dict, Optional
-from pathlib import Path
-
-from ..base import ServiceDependencies
-from .models import ContextBuildRequest, ContextResult
-
-
-class CodeExtractor:
-    """Handles extraction of code samples for context building."""
-    
-    def __init__(self):
-        """Initialize code extractor."""
-        # Map features to their corresponding files
-        self.feature_files = {
-            "models": "models.py",
-            "views": "views.py", 
-            "urls": "urls.py",
-            "admin": "admin.py",
-            "forms": "forms.py",
-            "tests": "tests.py",
-            "serializers": "serializers.py",
-            "viewsets": "viewsets.py",
-            "filters": "filters.py",
-            "pagination": "pagination.py",
-            "tasks": "tasks.py",
-            "signals": "signals.py",
-            "middleware": "middleware.py"
-        }
-    
-    async def extract_code_samples(
-        self,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Extract relevant code samples for context."""
-        if not request.generation_request:
-            return
-        
-        samples = {}
-        
-        # Extract samples for each requested feature
-        for feature in request.generation_request.features:
-            feature_samples = await self._extract_feature_samples(
-                feature.value, request, result, dependencies
-            )
-            if feature_samples:
-                samples[feature.value] = feature_samples
-        
-        result.code_samples = samples
-    
-    async def _extract_feature_samples(
-        self,
-        feature: str,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> Optional[str]:
-        """Extract code samples for a specific feature."""
-        # Find the best example of this feature in existing apps
-        best_sample = None
-        max_complexity = 0
-        
-        for app in result.project_context.apps:
-            app_path = Path(app.path)
-            
-            filename = self.feature_files.get(feature)
-            if not filename:
-                continue
-            
-            file_path = app_path / filename
-            if not file_path.exists():
-                continue
-            
-            try:
-                content = file_path.read_text()
-                
-                # Simple complexity measure (lines of meaningful code)
-                lines = [line.strip() for line in content.split('\n')]
-                meaningful_lines = [line for line in lines if line and not line.startswith('#')]
-                complexity = len(meaningful_lines)
-                
-                if complexity > max_complexity:
-                    max_complexity = complexity
-                    # Truncate sample if too long
-                    if len(content) > 2000:
-                        content = content[:2000] + "\n# ... (truncated)"
-                    best_sample = content
-                    
-            except Exception:
-                continue
-        
-        return best_sample
-    
-    def extract_specific_patterns(
-        self,
-        project_root: Path,
-        pattern_type: str,
-        max_samples: int = 3
-    ) -> Dict[str, str]:
-        """Extract specific code patterns from the project."""
-        samples = {}
-        
-        pattern_searches = {
-            "model_definitions": ["models.py"],
-            "view_classes": ["views.py"],
-            "url_patterns": ["urls.py"],
-            "admin_configs": ["admin.py"],
-            "serializer_classes": ["serializers.py"],
-            "test_cases": ["tests.py", "test_*.py"]
-        }
-        
-        search_files = pattern_searches.get(pattern_type, [])
-        
-        for search_pattern in search_files:
-            for file_path in project_root.rglob(search_pattern):
-                if file_path.is_file():
-                    try:
-                        content = file_path.read_text()
-                        relative_path = file_path.relative_to(project_root)
-                        
-                        # Truncate if too long
-                        if len(content) > 1500:
-                            content = content[:1500] + "\n# ... (truncated)"
-                        
-                        samples[str(relative_path)] = content
-                        
-                        # Limit number of samples
-                        if len(samples) >= max_samples:
-                            break
-                    except Exception:
-                        continue
-        
-        return samples

django_cfg/modules/django_app_agent/services/context_builder/context_generator.py

@@ -1,276 +0,0 @@
-"""
-Context Generation Module for Context Builder.
-
-This module handles generation of specific context for different
-Django features and components.
-"""
-
-from typing import List, Dict, Any
-from pathlib import Path
-import re
-
-from ..base import ServiceDependencies
-from .models import ContextBuildRequest, ContextResult
-
-
-class ContextGenerator:
-    """Handles generation of feature-specific context."""
-    
-    def __init__(self):
-        """Initialize context generator."""
-        # Map features to their context building strategies
-        self.context_strategies = {
-            "models": self._build_models_context,
-            "views": self._build_views_context,
-            "urls": self._build_urls_context,
-            "admin": self._build_admin_context,
-            "api": self._build_api_context,
-            "tests": self._build_tests_context,
-            "serializers": self._build_api_context,
-            "viewsets": self._build_api_context,
-            "forms": self._build_forms_context
-        }
-    
-    async def build_generation_context(
-        self,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Build context specific to the generation request."""
-        gen_request = request.generation_request
-        if not gen_request:
-            return
-        
-        # Build context for each requested feature
-        for feature in gen_request.features:
-            feature_name = feature.value
-            
-            if feature_name in self.context_strategies:
-                strategy = self.context_strategies[feature_name]
-                await strategy(request, result, dependencies)
-    
-    async def _build_models_context(
-        self,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Build context for models generation."""
-        # Find existing models in the project
-        existing_models = []
-        
-        for app in result.project_context.apps:
-            if app.models_count > 0:
-                app_path = Path(app.path)
-                models_file = app_path / "models.py"
-                
-                if models_file.exists():
-                    try:
-                        content = models_file.read_text()
-                        # Extract model class names
-                        model_classes = re.findall(r'class\s+(\w+)\s*\([^)]*Model[^)]*\):', content)
-                        existing_models.extend([(app.name, model) for model in model_classes])
-                    except Exception:
-                        pass
-        
-        # Add to context summary
-        result.context_summary["existing_models"] = existing_models
-        result.context_summary["model_patterns"] = [
-            p for p in result.relevant_patterns 
-            if "model" in p.name.lower() or "data" in p.name.lower()
-        ]
-    
-    async def _build_views_context(
-        self,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Build context for views generation."""
-        # Find existing view patterns
-        view_patterns = []
-        
-        for app in result.project_context.apps:
-            if app.views_count > 0:
-                app_path = Path(app.path)
-                views_file = app_path / "views.py"
-                
-                if views_file.exists():
-                    try:
-                        content = views_file.read_text()
-                        
-                        # Detect view types
-                        if "class" in content and "View" in content:
-                            view_patterns.append("class_based_views")
-                        if "def " in content and "request" in content:
-                            view_patterns.append("function_based_views")
-                        if "async def" in content:
-                            view_patterns.append("async_views")
-                            
-                    except Exception:
-                        pass
-        
-        result.context_summary["view_patterns"] = list(set(view_patterns))
-    
-    async def _build_urls_context(
-        self,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Build context for URLs generation."""
-        # Analyze URL patterns in existing apps
-        url_patterns = []
-        
-        for app in result.project_context.apps:
-            app_path = Path(app.path)
-            urls_file = app_path / "urls.py"
-            
-            if urls_file.exists():
-                try:
-                    content = urls_file.read_text()
-                    
-                    # Detect URL pattern styles
-                    if "path(" in content:
-                        url_patterns.append("django_path")
-                    if "re_path(" in content:
-                        url_patterns.append("regex_path")
-                    if "include(" in content:
-                        url_patterns.append("url_include")
-                        
-                except Exception:
-                    pass
-        
-        result.context_summary["url_patterns"] = list(set(url_patterns))
-    
-    async def _build_admin_context(
-        self,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Build context for admin generation."""
-        # Find admin registration patterns
-        admin_patterns = []
-        
-        for app in result.project_context.apps:
-            if app.admin_registered_models > 0:
-                app_path = Path(app.path)
-                admin_file = app_path / "admin.py"
-                
-                if admin_file.exists():
-                    try:
-                        content = admin_file.read_text()
-                        
-                        # Detect admin patterns
-                        if "@admin.register" in content:
-                            admin_patterns.append("decorator_registration")
-                        if "admin.site.register" in content:
-                            admin_patterns.append("function_registration")
-                        if "ModelAdmin" in content:
-                            admin_patterns.append("custom_admin_classes")
-                            
-                    except Exception:
-                        pass
-        
-        result.context_summary["admin_patterns"] = list(set(admin_patterns))
-    
-    async def _build_api_context(
-        self,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Build context for API generation."""
-        # Find API patterns
-        api_patterns = []
-        
-        for app in result.project_context.apps:
-            app_path = Path(app.path)
-            
-            # Check for DRF patterns
-            for api_file in ["serializers.py", "viewsets.py", "views.py"]:
-                file_path = app_path / api_file
-                if file_path.exists():
-                    try:
-                        content = file_path.read_text()
-                        
-                        if "rest_framework" in content:
-                            api_patterns.append("django_rest_framework")
-                        if "Serializer" in content:
-                            api_patterns.append("serializers")
-                        if "ViewSet" in content:
-                            api_patterns.append("viewsets")
-                        if "APIView" in content:
-                            api_patterns.append("api_views")
-                            
-                    except Exception:
-                        pass
-        
-        result.context_summary["api_patterns"] = list(set(api_patterns))
-    
-    async def _build_tests_context(
-        self,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Build context for tests generation."""
-        # Find testing patterns
-        test_patterns = []
-        
-        for app in result.project_context.apps:
-            app_path = Path(app.path)
-            
-            # Check for test files
-            test_files = list(app_path.glob("test*.py")) + [app_path / "tests.py"]
-            
-            for test_file in test_files:
-                if test_file.exists():
-                    try:
-                        content = test_file.read_text()
-                        
-                        if "TestCase" in content:
-                            test_patterns.append("django_testcase")
-                        if "pytest" in content or "def test_" in content:
-                            test_patterns.append("pytest")
-                        if "Client" in content:
-                            test_patterns.append("test_client")
-                        if "factory" in content.lower():
-                            test_patterns.append("factory_boy")
-                            
-                    except Exception:
-                        pass
-        
-        result.context_summary["test_patterns"] = list(set(test_patterns))
-    
-    async def _build_forms_context(
-        self,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Build context for forms generation."""
-        # Find form patterns
-        form_patterns = []
-        
-        for app in result.project_context.apps:
-            app_path = Path(app.path)
-            forms_file = app_path / "forms.py"
-            
-            if forms_file.exists():
-                try:
-                    content = forms_file.read_text()
-                    
-                    if "ModelForm" in content:
-                        form_patterns.append("model_forms")
-                    if "Form" in content and "ModelForm" not in content:
-                        form_patterns.append("regular_forms")
-                    if "widgets" in content:
-                        form_patterns.append("custom_widgets")
-                        
-                except Exception:
-                    pass
-        
-        result.context_summary["form_patterns"] = list(set(form_patterns))

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

@@ -1,272 +0,0 @@
-"""
-Main Context Builder Service for Django App Agent Module.
-
-This service builds comprehensive development context for AI agents,
-coordinating project analysis, pattern identification, and context optimization.
-"""
-
-from typing import Dict, Any, List
-
-from ..base import BaseService, ServiceDependencies
-from ..project_scanner import ProjectScannerService, ProjectScanRequest
-from ...models.context import ProjectContext
-from ...core.exceptions import ValidationError
-
-from .models import ContextBuildRequest, ContextResult
-from .pattern_analyzer import PatternAnalyzer
-from .code_extractor import CodeExtractor
-from .context_generator import ContextGenerator
-
-
-class ContextBuilderService(BaseService[ContextBuildRequest, ContextResult]):
-    """
-    Service for building comprehensive development context for AI agents.
-    
-    Capabilities:
-    - Project structure analysis and pattern identification
-    - Code sample extraction and context building
-    - Integration point identification
-    - Context optimization for AI consumption
-    """
-    
-    def __init__(self, config):
-        """Initialize context builder service."""
-        super().__init__("context_builder", config)
-        
-        # Initialize sub-components
-        self.pattern_analyzer = PatternAnalyzer()
-        self.code_extractor = CodeExtractor()
-        self.context_generator = ContextGenerator()
-        
-        # Initialize project scanner
-        self.project_scanner = ProjectScannerService(config)
-    
-    async def process(
-        self, 
-        request: ContextBuildRequest, 
-        dependencies: ServiceDependencies
-    ) -> ContextResult:
-        """
-        Process context building request.
-        
-        Args:
-            request: Context building request
-            dependencies: Service dependencies for logging and operations
-            
-        Returns:
-            ContextResult with comprehensive development context
-        """
-        try:
-            dependencies.log_operation(
-                f"Building development context for '{request.project_root}'",
-                project_root=str(request.project_root),
-                target_app=request.target_app_name
-            )
-            
-            # Initialize result
-            result = ContextResult(
-                project_context=ProjectContext(
-                    project_root=str(request.project_root),
-                    project_name=request.project_root.name,
-                    django_version="Unknown",
-                    is_django_cfg_project=False,
-                    apps=[],
-                    architectural_patterns=[],
-                    integration_opportunities=[]
-                )
-            )
-            
-            # Scan project structure
-            scan_request = ProjectScanRequest(
-                project_root=request.project_root,
-                analyze_dependencies=True,
-                detect_patterns=True
-            )
-            
-            scan_result = await self.project_scanner.process(scan_request, dependencies)
-            result.project_context = scan_result.project_context
-            
-            # Identify relevant architectural patterns
-            await self.pattern_analyzer.identify_relevant_patterns(
-                request, scan_result, result, dependencies
-            )
-            
-            # Build generation-specific context
-            await self.context_generator.build_generation_context(
-                request, result, dependencies
-            )
-            
-            # Extract code samples if requested
-            if request.include_code_samples:
-                await self.code_extractor.extract_code_samples(
-                    request, result, dependencies
-                )
-            
-            # Identify integration points
-            await self._identify_integration_points(request, result, dependencies)
-            
-            # Generate recommendations
-            await self._generate_recommendations(request, result, dependencies)
-            
-            # Optimize context size if needed
-            await self._optimize_context_size(request, result, dependencies)
-            
-            dependencies.log_operation(
-                "Context building completed successfully",
-                patterns_found=len(result.relevant_patterns),
-                code_samples=len(result.code_samples),
-                recommendations=len(result.recommendations)
-            )
-            
-            return result
-            
-        except Exception as e:
-            raise ValidationError(
-                f"Failed to build development context: {e}",
-                validation_type="context_building"
-            )
-    
-    async def _identify_integration_points(
-        self,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Identify potential integration points with existing code."""
-        integration_points = []
-        
-        if not request.generation_request:
-            return
-        
-        # Check for potential integrations based on requested features
-        for feature in request.generation_request.features:
-            feature_name = feature.value
-            
-            if feature_name == "models":
-                # Look for existing models that could be related
-                for app in result.project_context.apps:
-                    if app.models_count > 0:
-                        integration_points.append({
-                            "type": "model_relationships",
-                            "app": app.name,
-                            "description": f"Consider relationships with models in {app.name}",
-                            "confidence": 0.7
-                        })
-            
-            elif feature_name == "api":
-                # Look for existing API patterns
-                api_apps = [app for app in result.project_context.apps if "api" in app.name.lower()]
-                for app in api_apps:
-                    integration_points.append({
-                        "type": "api_integration",
-                        "app": app.name,
-                        "description": f"Consider API consistency with {app.name}",
-                        "confidence": 0.8
-                    })
-            
-            elif feature_name == "admin":
-                # Look for existing admin customizations
-                admin_apps = [app for app in result.project_context.apps if app.admin_registered_models > 0]
-                for app in admin_apps:
-                    integration_points.append({
-                        "type": "admin_consistency",
-                        "app": app.name,
-                        "description": f"Follow admin patterns from {app.name}",
-                        "confidence": 0.6
-                    })
-        
-        result.integration_points = integration_points
-    
-    async def _generate_recommendations(
-        self,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Generate development recommendations based on context."""
-        recommendations = []
-        
-        # Analyze project patterns for recommendations
-        if result.relevant_patterns:
-            high_confidence_patterns = [p for p in result.relevant_patterns if p.confidence >= 0.8]
-            if high_confidence_patterns:
-                pattern_names = [p.name for p in high_confidence_patterns]
-                recommendations.append(
-                    f"Follow established patterns: {', '.join(pattern_names)}"
-                )
-        
-        # Check for django-cfg specific recommendations
-        if result.project_context.is_django_cfg_project:
-            recommendations.extend([
-                "Use django-cfg configuration patterns for settings",
-                "Leverage django-cfg modules for better organization",
-                "Consider using BaseCfgModule for configuration management"
-            ])
-        
-        # Feature-specific recommendations
-        if request.generation_request:
-            for feature in request.generation_request.features:
-                feature_name = feature.value
-                
-                if feature_name == "models":
-                    recommendations.append("Use proper field types and validation")
-                    recommendations.append("Add meaningful __str__ methods")
-                    recommendations.append("Consider adding Meta class with ordering")
-                
-                elif feature_name == "api":
-                    recommendations.append("Use DRF serializers for consistent API responses")
-                    recommendations.append("Implement proper pagination")
-                    recommendations.append("Add API documentation with drf-spectacular")
-                
-                elif feature_name == "tests":
-                    recommendations.append("Aim for high test coverage")
-                    recommendations.append("Use factory_boy for test data generation")
-                    recommendations.append("Test both positive and negative scenarios")
-        
-        # Context size recommendations
-        context_size = sum(len(str(v)) for v in result.code_samples.values())
-        if context_size > request.max_context_size:
-            recommendations.append("Consider reducing context size for better AI performance")
-        
-        result.recommendations = recommendations
-    
-    async def _optimize_context_size(
-        self,
-        request: ContextBuildRequest,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Optimize context size to fit within limits."""
-        # Calculate current context size
-        context_size = 0
-        context_size += len(str(result.project_context))
-        context_size += sum(len(str(p)) for p in result.relevant_patterns)
-        context_size += sum(len(sample) for sample in result.code_samples.values())
-        
-        if context_size <= request.max_context_size:
-            return
-        
-        dependencies.log_operation(
-            f"Optimizing context size from {context_size} to {request.max_context_size}"
-        )
-        
-        # Prioritize and truncate content
-        # 1. Keep most relevant patterns (highest confidence)
-        result.relevant_patterns = sorted(
-            result.relevant_patterns, 
-            key=lambda p: p.confidence, 
-            reverse=True
-        )[:5]  # Keep top 5 patterns
-        
-        # 2. Truncate code samples
-        max_sample_size = request.max_context_size // (len(result.code_samples) + 1) if result.code_samples else 1000
-        
-        for feature, sample in result.code_samples.items():
-            if len(sample) > max_sample_size:
-                result.code_samples[feature] = sample[:max_sample_size] + "\n# ... (truncated for context)"
-        
-        # 3. Limit integration points
-        result.integration_points = result.integration_points[:10]
-        
-        # 4. Limit recommendations
-        result.recommendations = result.recommendations[:15]