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

django_cfg/modules/django_app_agent/services/validation_service/syntax_validator.py

@@ -0,0 +1,203 @@
+"""
+Syntax Validator for Django App Agent.
+
+This module provides Python syntax validation and AST analysis
+for generated code files.
+"""
+
+from typing import List, Dict, Any, Optional
+import ast
+import re
+
+from pydantic import BaseModel, Field
+
+from ...models.responses import GeneratedFile
+from ..base import ServiceDependencies
+from .models import ValidationIssue
+
+
+class SyntaxValidator(BaseModel):
+    """Validates Python syntax and performs AST analysis."""
+    
+    syntax_rules: Dict[str, Dict[str, Any]] = Field(
+        default_factory=lambda: {
+            "valid_python": {
+                "description": "Code must be valid Python syntax",
+                "severity": "error"
+            },
+            "no_syntax_errors": {
+                "description": "No syntax errors allowed",
+                "severity": "error"
+            },
+            "proper_indentation": {
+                "description": "Code must use consistent indentation",
+                "severity": "warning"
+            },
+            "no_unused_imports": {
+                "description": "No unused imports allowed",
+                "severity": "warning"
+            }
+        },
+        description="Syntax validation rules"
+    )
+
+    async def validate_syntax(
+        self,
+        file: GeneratedFile,
+        dependencies: ServiceDependencies
+    ) -> List[ValidationIssue]:
+        """Validate Python syntax for a single file."""
+        issues = []
+        
+        if file.file_type != "python":
+            return issues
+        
+        try:
+            # Parse the AST
+            tree = ast.parse(file.content)
+            
+            # Check for syntax issues
+            issues.extend(self._check_ast_structure(file, tree, dependencies))
+            issues.extend(self._check_imports(file, tree, dependencies))
+            issues.extend(self._check_indentation(file, dependencies))
+            
+        except SyntaxError as e:
+            issues.append(ValidationIssue(
+                severity="error",
+                category="syntax",
+                message=f"Syntax error: {e.msg}",
+                file_path=file.path,
+                line_number=e.lineno or 1,
+                column=e.offset,
+                rule_id="syntax_error",
+                suggestion="Fix the syntax error according to Python grammar rules"
+            ))
+        except Exception as e:
+            issues.append(ValidationIssue(
+                severity="error",
+                category="syntax",
+                message=f"Failed to parse file: {e}",
+                file_path=file.path,
+                line_number=1,
+                rule_id="parse_error"
+            ))
+        
+        return issues
+    
+    def _check_ast_structure(
+        self,
+        file: GeneratedFile,
+        tree: ast.AST,
+        dependencies: ServiceDependencies
+    ) -> List[ValidationIssue]:
+        """Check AST structure for common issues."""
+        issues = []
+        
+        # Check for empty classes/functions
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
+                if len(node.body) == 1 and isinstance(node.body[0], ast.Pass):
+                    issues.append(ValidationIssue(
+                        severity="warning",
+                        category="syntax",
+                        message=f"Empty {type(node).__name__.lower()} '{node.name}' with only 'pass'",
+                        file_path=file.path,
+                        line_number=node.lineno,
+                        rule_id="empty_definition",
+                        suggestion=f"Add implementation or docstring to {node.name}"
+                    ))
+        
+        return issues
+    
+    def _check_imports(
+        self,
+        file: GeneratedFile,
+        tree: ast.AST,
+        dependencies: ServiceDependencies
+    ) -> List[ValidationIssue]:
+        """Check import statements for issues."""
+        issues = []
+        
+        # Collect all imports and their usage
+        imports = set()
+        used_names = set()
+        
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    import_name = alias.asname or alias.name
+                    imports.add(import_name)
+            elif isinstance(node, ast.ImportFrom):
+                for alias in node.names:
+                    import_name = alias.asname or alias.name
+                    imports.add(import_name)
+            elif isinstance(node, ast.Name):
+                used_names.add(node.id)
+            elif isinstance(node, ast.Attribute):
+                # Handle attribute access like 'models.Model'
+                if isinstance(node.value, ast.Name):
+                    used_names.add(node.value.id)
+        
+        # Check for unused imports
+        unused_imports = imports - used_names
+        for unused in unused_imports:
+            # Skip common Django imports that might be used in templates
+            if unused not in ['models', 'admin', 'forms', 'serializers']:
+                issues.append(ValidationIssue(
+                    severity="warning",
+                    category="syntax",
+                    message=f"Unused import: {unused}",
+                    file_path=file.path,
+                    line_number=1,  # Would need more sophisticated tracking for exact line
+                    rule_id="unused_import",
+                    suggestion=f"Remove unused import '{unused}' or use it in the code"
+                ))
+        
+        return issues
+    
+    def _check_indentation(
+        self,
+        file: GeneratedFile,
+        dependencies: ServiceDependencies
+    ) -> List[ValidationIssue]:
+        """Check for consistent indentation."""
+        issues = []
+        lines = file.content.split('\n')
+        
+        # Check for mixed tabs and spaces
+        has_tabs = any('\t' in line for line in lines)
+        has_spaces = any(line.startswith('    ') for line in lines)
+        
+        if has_tabs and has_spaces:
+            issues.append(ValidationIssue(
+                severity="warning",
+                category="syntax",
+                message="Mixed tabs and spaces for indentation",
+                file_path=file.path,
+                line_number=1,
+                rule_id="mixed_indentation",
+                suggestion="Use consistent indentation (preferably 4 spaces)"
+            ))
+        
+        # Check for inconsistent indentation levels
+        indent_levels = set()
+        for i, line in enumerate(lines, 1):
+            if line.strip():  # Skip empty lines
+                leading_spaces = len(line) - len(line.lstrip(' '))
+                if leading_spaces > 0:
+                    indent_levels.add(leading_spaces)
+        
+        # Check if indentation follows 4-space rule
+        non_standard_indents = [level for level in indent_levels if level % 4 != 0]
+        if non_standard_indents:
+            issues.append(ValidationIssue(
+                severity="info",
+                category="syntax",
+                message=f"Non-standard indentation levels found: {non_standard_indents}",
+                file_path=file.path,
+                line_number=1,
+                rule_id="non_standard_indent",
+                suggestion="Use 4-space indentation consistently"
+            ))
+        
+        return issues

django_cfg/modules/django_app_agent/ui/__init__.py

@@ -0,0 +1,25 @@
+"""
+User Interface Components for Django App Agent Module.
+
+This module provides rich terminal UI components using Rich library
+for beautiful and interactive command-line interfaces.
+"""
+
+from .cli import DjangoAppAgentCLI
+from .rich_components import (
+    RichProgressTracker,
+    RichQuestionInterface,
+    RichErrorDisplay,
+    RichStatusDisplay
+)
+
+__all__ = [
+    # Main CLI interface
+    "DjangoAppAgentCLI",
+    
+    # Rich UI components
+    "RichProgressTracker",
+    "RichQuestionInterface", 
+    "RichErrorDisplay",
+    "RichStatusDisplay",
+]

django_cfg/modules/django_app_agent/ui/cli.py

@@ -0,0 +1,419 @@
+"""
+Main CLI Interface for Django App Agent Module.
+
+This module provides the primary command-line interface using Click
+with Rich integration for beautiful terminal output.
+"""
+
+from typing import Optional, List, Dict, Any
+from pathlib import Path
+import asyncio
+import sys
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.prompt import Prompt, Confirm
+from rich.table import Table
+
+from ..core.config import AgentConfig
+from ..models.requests import AppGenerationRequest
+from ..models.enums import AppType, AppComplexity, AppFeature
+from ..services.app_generator import AppGeneratorService
+from ..services.project_scanner import ProjectScannerService
+from ..services.base import create_service_dependencies
+from ..utils.logging import get_logger
+from .rich_components import RichProgressTracker, RichQuestionInterface, RichErrorDisplay
+
+
+class DjangoAppAgentCLI:
+    """
+    Main CLI interface for Django App Agent.
+    
+    Provides commands for:
+    - Interactive application generation
+    - Project scanning and analysis
+    - Batch processing
+    - Configuration management
+    """
+    
+    def __init__(self):
+        """Initialize CLI interface."""
+        self.console = Console()
+        self.logger = get_logger("cli")
+        self.config = None
+        self.progress_tracker = RichProgressTracker(self.console)
+        self.question_interface = RichQuestionInterface(self.console)
+        self.error_display = RichErrorDisplay(self.console)
+    
+    def _load_config(self) -> AgentConfig:
+        """Load agent configuration."""
+        if self.config is None:
+            try:
+                # In real implementation, this would load from django-cfg
+                self.config = AgentConfig()
+            except Exception as e:
+                self.error_display.show_error(
+                    "Configuration Error",
+                    f"Failed to load configuration: {e}",
+                    suggestions=["Check django-cfg setup", "Verify API keys"]
+                )
+                sys.exit(1)
+        return self.config
+    
+    def _show_welcome(self):
+        """Show welcome message."""
+        welcome_text = Text()
+        welcome_text.append("🚀 Django App Agent", style="bold blue")
+        welcome_text.append("\nAI-Powered Django Application Generator", style="italic")
+        
+        panel = Panel(
+            welcome_text,
+            title="Welcome",
+            border_style="blue",
+            padding=(1, 2)
+        )
+        self.console.print(panel)
+        self.console.print()
+    
+    def _show_app_types(self) -> AppType:
+        """Show application type selection."""
+        self.console.print("[bold]Select Application Type:[/bold]")
+        
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Option", style="cyan", width=10)
+        table.add_column("Type", style="green")
+        table.add_column("Description")
+        
+        table.add_row("1", "Django", "Standard Django application")
+        table.add_row("2", "Django-CFG", "Django-CFG enhanced application with configuration management")
+        
+        self.console.print(table)
+        self.console.print()
+        
+        while True:
+            choice = Prompt.ask("Choose application type", choices=["1", "2"], default="2")
+            if choice == "1":
+                return AppType.DJANGO
+            elif choice == "2":
+                return AppType.DJANGO_CFG
+    
+    def _show_complexity_levels(self) -> AppComplexity:
+        """Show complexity level selection."""
+        self.console.print("[bold]Select Complexity Level:[/bold]")
+        
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Option", style="cyan", width=10)
+        table.add_column("Level", style="green")
+        table.add_column("Description")
+        table.add_column("Est. Time", style="yellow")
+        
+        table.add_row("1", "Basic", "Simple app with core features", "~5 min")
+        table.add_row("2", "Moderate", "Standard app with common features", "~15 min")
+        table.add_row("3", "Advanced", "Complex app with advanced features", "~30 min")
+        table.add_row("4", "Enterprise", "Full-featured enterprise application", "~60 min")
+        
+        self.console.print(table)
+        self.console.print()
+        
+        choice = Prompt.ask("Choose complexity level", choices=["1", "2", "3", "4"], default="2")
+        
+        complexity_map = {
+            "1": AppComplexity.SIMPLE,
+            "2": AppComplexity.MODERATE,
+            "3": AppComplexity.ADVANCED,
+            "4": AppComplexity.ENTERPRISE
+        }
+        
+        return complexity_map[choice]
+    
+    def _select_features(self, complexity: AppComplexity) -> List[AppFeature]:
+        """Interactive feature selection."""
+        recommended = complexity.get_recommended_features()
+        
+        self.console.print(f"[bold]Select Features for {complexity.value.title()} Application:[/bold]")
+        self.console.print(f"[dim]Recommended features are pre-selected[/dim]")
+        self.console.print()
+        
+        # Show available features
+        all_features = list(AppFeature)
+        selected_features = set(recommended)
+        
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Feature", style="green")
+        table.add_column("Selected", style="cyan", width=10)
+        table.add_column("Description")
+        
+        for feature in all_features:
+            selected = "✓" if feature in selected_features else " "
+            description = self._get_feature_description(feature)
+            style = "green" if feature in selected_features else "dim"
+            table.add_row(feature.value, selected, description, style=style)
+        
+        self.console.print(table)
+        self.console.print()
+        
+        # Allow customization
+        if Confirm.ask("Customize feature selection?", default=False):
+            selected_features = self._customize_features(all_features, selected_features)
+        
+        return list(selected_features)
+    
+    def _customize_features(self, all_features: List[AppFeature], current: set) -> set:
+        """Allow user to customize feature selection."""
+        selected = current.copy()
+        
+        self.console.print("[bold]Feature Customization:[/bold]")
+        self.console.print("[dim]Type feature name to toggle, 'done' to finish[/dim]")
+        self.console.print()
+        
+        while True:
+            # Show current selection
+            self.console.print("[bold]Current selection:[/bold]")
+            for feature in all_features:
+                status = "✓" if feature in selected else " "
+                style = "green" if feature in selected else "dim"
+                self.console.print(f"  [{status}] {feature.value}", style=style)
+            
+            self.console.print()
+            
+            choice = Prompt.ask(
+                "Feature to toggle (or 'done')",
+                default="done"
+            ).lower()
+            
+            if choice == "done":
+                break
+            
+            # Find matching feature
+            matching_feature = None
+            for feature in all_features:
+                if feature.value.lower() == choice or feature.value.lower().startswith(choice):
+                    matching_feature = feature
+                    break
+            
+            if matching_feature:
+                if matching_feature in selected:
+                    selected.remove(matching_feature)
+                    self.console.print(f"[red]Removed {matching_feature.value}[/red]")
+                else:
+                    selected.add(matching_feature)
+                    self.console.print(f"[green]Added {matching_feature.value}[/green]")
+            else:
+                self.console.print(f"[red]Feature '{choice}' not found[/red]")
+            
+            self.console.print()
+        
+        return selected
+    
+    def _get_feature_description(self, feature: AppFeature) -> str:
+        """Get description for a feature."""
+        descriptions = {
+            AppFeature.MODELS: "Database models and ORM",
+            AppFeature.VIEWS: "View functions and classes",
+            AppFeature.URLS: "URL routing configuration",
+            AppFeature.ADMIN: "Django admin interface",
+            AppFeature.FORMS: "Form classes and validation",
+            AppFeature.TEMPLATES: "HTML templates",
+            AppFeature.API: "REST API with DRF",
+            AppFeature.TESTS: "Unit and integration tests",
+            AppFeature.TASKS: "Background tasks (Celery/Dramatiq)",
+            AppFeature.DOCS: "Auto-generated documentation",
+            AppFeature.CONFIG: "Configuration management",
+            AppFeature.SECURITY: "Security and permissions",
+            AppFeature.SIGNALS: "Django signals",
+            AppFeature.MANAGEMENT_COMMANDS: "Custom management commands",
+            AppFeature.MIDDLEWARE: "Custom middleware",
+            AppFeature.CONTEXT_PROCESSORS: "Template context processors",
+        }
+        return descriptions.get(feature, "Additional feature")
+    
+    async def _run_generation(self, request: AppGenerationRequest) -> None:
+        """Run application generation process."""
+        config = self._load_config()
+        
+        # Initialize services
+        generator_service = AppGeneratorService(config)
+        
+        # Create dependencies
+        deps = create_service_dependencies(
+            config=config,
+            service_name="cli_generation",
+            project_root=Path.cwd()
+        )
+        
+        # Start progress tracking
+        with self.progress_tracker.track_generation(request.app_name) as progress:
+            try:
+                # Run generation
+                result = await generator_service.process(request, deps)
+                
+                # Show results
+                if result.status == "success":
+                    self._show_success_result(result)
+                else:
+                    self._show_error_result(result)
+                    
+            except Exception as e:
+                self.error_display.show_error(
+                    "Generation Failed",
+                    str(e),
+                    suggestions=["Check configuration", "Verify permissions", "Try again"]
+                )
+    
+    def _show_success_result(self, result) -> None:
+        """Show successful generation result."""
+        self.console.print()
+        
+        success_panel = Panel(
+            f"✅ Successfully generated application '[bold green]{result.app_name}[/bold green]'\n"
+            f"📁 Files created: {len(result.generated_files)}\n"
+            f"⏱️  Duration: {result.duration_seconds:.1f} seconds",
+            title="Generation Complete",
+            border_style="green",
+            padding=(1, 2)
+        )
+        self.console.print(success_panel)
+        
+        # Show quality metrics if available
+        if result.quality_metrics:
+            metrics = result.quality_metrics
+            
+            metrics_table = Table(title="Quality Metrics", show_header=True)
+            metrics_table.add_column("Metric", style="cyan")
+            metrics_table.add_column("Score", style="green")
+            
+            metrics_table.add_row("Code Readability", f"{metrics.code_readability_score:.2f}/1.0")
+            metrics_table.add_row("Maintainability", f"{metrics.maintainability_score:.2f}/1.0")
+            metrics_table.add_row("Type Hints", f"{metrics.type_hint_completeness:.2f}/1.0")
+            metrics_table.add_row("Pydantic Compliance", f"{metrics.pydantic_compliance_score:.2f}/1.0")
+            metrics_table.add_row("Test Coverage", f"{metrics.test_coverage_percentage:.1f}%")
+            
+            self.console.print(metrics_table)
+        
+        # Show next steps
+        self.console.print()
+        self.console.print("[bold]Next Steps:[/bold]")
+        self.console.print("1. Add the app to your INSTALLED_APPS")
+        self.console.print("2. Run migrations: [cyan]python manage.py makemigrations && python manage.py migrate[/cyan]")
+        self.console.print("3. Include URLs in your main urls.py")
+        self.console.print("4. Start development!")
+    
+    def _show_error_result(self, result) -> None:
+        """Show error generation result."""
+        self.error_display.show_error(
+            "Generation Failed",
+            result.message,
+            errors=result.errors,
+            warnings=result.warnings
+        )
+
+
+# Click CLI commands
+@click.group()
+@click.version_option(version="0.1.0", prog_name="Django App Agent")
+def cli():
+    """🚀 Django App Agent - AI-Powered Django Application Generator"""
+    pass
+
+
+@cli.command()
+@click.option('--app-name', prompt='Application name', help='Name of the Django application')
+@click.option('--description', prompt='Description', help='Brief description of the application')
+@click.option('--app-type', type=click.Choice(['django', 'django_cfg']), default='django_cfg', help='Application type')
+@click.option('--complexity', type=click.Choice(['basic', 'moderate', 'advanced', 'enterprise']), default='moderate', help='Complexity level')
+@click.option('--output-dir', type=click.Path(), help='Output directory')
+@click.option('--interactive/--no-interactive', default=True, help='Interactive mode')
+def generate(app_name: str, description: str, app_type: str, complexity: str, output_dir: Optional[str], interactive: bool):
+    """Generate a new Django application with AI assistance."""
+    
+    cli_interface = DjangoAppAgentCLI()
+    
+    if interactive:
+        cli_interface._show_welcome()
+        
+        # Interactive mode
+        app_type_enum = cli_interface._show_app_types()
+        complexity_enum = cli_interface._show_complexity_levels()
+        features = cli_interface._select_features(complexity_enum)
+        
+    else:
+        # Non-interactive mode
+        app_type_enum = AppType.DJANGO_CFG if app_type == 'django_cfg' else AppType.DJANGO
+        complexity_enum = AppComplexity(complexity)
+        features = list(complexity_enum.get_recommended_features())
+    
+    # Create generation request
+    request = AppGenerationRequest(
+        app_name=app_name,
+        description=description,
+        app_type=app_type_enum,
+        complexity=complexity_enum,
+        features=features,
+        output_directory=output_dir
+    )
+    
+    # Run generation
+    asyncio.run(cli_interface._run_generation(request))
+
+
+@cli.command()
+@click.option('--project-root', type=click.Path(exists=True), default='.', help='Project root directory')
+@click.option('--output-format', type=click.Choice(['table', 'json']), default='table', help='Output format')
+def scan(project_root: str, output_format: str):
+    """Scan and analyze Django project structure."""
+    
+    cli_interface = DjangoAppAgentCLI()
+    config = cli_interface._load_config()
+    
+    async def run_scan():
+        scanner_service = ProjectScannerService(config)
+        
+        request = ProjectScanRequest(
+            project_root=Path(project_root),
+            scan_depth=3,
+            analyze_dependencies=True,
+            detect_patterns=True
+        )
+        
+        deps = create_service_dependencies(
+            config=config,
+            service_name="cli_scan",
+            project_root=Path(project_root)
+        )
+        
+        with cli_interface.progress_tracker.track_scanning() as progress:
+            result = await scanner_service.process(request, deps)
+        
+        # Display results
+        if output_format == 'table':
+            cli_interface._show_scan_table(result)
+        else:
+            cli_interface._show_scan_json(result)
+    
+    asyncio.run(run_scan())
+
+
+@cli.command()
+def config():
+    """Show current configuration."""
+    
+    cli_interface = DjangoAppAgentCLI()
+    config = cli_interface._load_config()
+    
+    # Show configuration in a nice table
+    config_table = Table(title="Django App Agent Configuration", show_header=True)
+    config_table.add_column("Setting", style="cyan")
+    config_table.add_column("Value", style="green")
+    
+    # Add configuration rows (this would be populated from actual config)
+    config_table.add_row("Version", "0.1.0")
+    config_table.add_row("Default App Type", "django_cfg")
+    config_table.add_row("AI Provider", "OpenRouter")
+    
+    cli_interface.console.print(config_table)
+
+
+if __name__ == '__main__':
+    cli()