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

django_cfg/modules/django_app_agent/services/project_scanner/models.py

@@ -0,0 +1,59 @@
+"""
+Data Models for Project Scanner Service.
+
+This module contains Pydantic models for project scanning
+requests, results, and related data structures.
+"""
+
+from typing import List, Dict, Any
+from pathlib import Path
+
+from pydantic import BaseModel, Field, ConfigDict
+
+from ...models.context import ProjectContext, DjangoAppInfo, ArchitecturalPattern
+from ...core.exceptions import ValidationError
+
+
+class ProjectScanRequest(BaseModel):
+    """Request for project scanning operation."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    project_root: Path = Field(description="Root directory of the project to scan")
+    scan_depth: int = Field(default=3, ge=1, le=10, description="Maximum directory depth to scan")
+    include_patterns: List[str] = Field(
+        default_factory=lambda: ["*.py", "*.md", "*.txt", "*.yml", "*.yaml", "*.json"],
+        description="File patterns to include in scanning"
+    )
+    exclude_patterns: List[str] = Field(
+        default_factory=lambda: ["__pycache__", "*.pyc", ".git", "node_modules", "venv", ".env"],
+        description="File/directory patterns to exclude from scanning"
+    )
+    analyze_dependencies: bool = Field(default=True, description="Whether to analyze dependencies")
+    detect_patterns: bool = Field(default=True, description="Whether to detect architectural patterns")
+    
+    def model_post_init(self, __context: Any) -> None:
+        """Validate project root exists."""
+        if not self.project_root.exists():
+            raise ValidationError(
+                f"Project root directory does not exist: {self.project_root}",
+                validation_type="project_path"
+            )
+        if not self.project_root.is_dir():
+            raise ValidationError(
+                f"Project root is not a directory: {self.project_root}",
+                validation_type="project_path"
+            )
+
+
+class ScanResult(BaseModel):
+    """Result of project scanning operation."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    project_context: ProjectContext = Field(description="Comprehensive project context")
+    discovered_apps: List[DjangoAppInfo] = Field(default_factory=list, description="Discovered Django applications")
+    architectural_patterns: List[ArchitecturalPattern] = Field(default_factory=list, description="Detected architectural patterns")
+    file_summary: Dict[str, Any] = Field(default_factory=dict, description="File structure summary")
+    dependency_graph: Dict[str, List[str]] = Field(default_factory=dict, description="Application dependency graph")
+    scan_statistics: Dict[str, int] = Field(default_factory=dict, description="Scanning statistics")

django_cfg/modules/django_app_agent/services/project_scanner/pattern_detection.py

@@ -0,0 +1,94 @@
+"""
+Architectural Pattern Detection Module for Project Scanner.
+
+This module handles detection of architectural patterns and
+conventions within Django/django-cfg projects.
+"""
+
+from typing import List, Dict, Any
+from pathlib import Path
+
+from ...models.context import ArchitecturalPattern
+from ..base import ServiceDependencies
+from .models import ProjectScanRequest, ScanResult
+
+
+class PatternDetectionEngine:
+    """Handles detection of architectural patterns in projects."""
+    
+    def __init__(self):
+        """Initialize pattern detection engine."""
+        # Architectural pattern indicators
+        self.pattern_indicators = {
+            "mvc_pattern": ["models.py", "views.py", "templates/"],
+            "api_pattern": ["serializers.py", "viewsets.py", "api/"],
+            "service_layer": ["services/", "services.py"],
+            "repository_pattern": ["repositories/", "repository.py"],
+            "factory_pattern": ["factories/", "factory.py"],
+            "command_pattern": ["management/commands/", "commands/"],
+            "observer_pattern": ["signals.py", "observers/"],
+            "middleware_pattern": ["middleware.py", "middleware/"],
+            "django_cfg_pattern": ["config.py", "cfg_config.py", "modules/"],
+            "rest_api": ["rest_framework", "serializers.py", "viewsets.py"],
+            "graphql_api": ["graphene", "schema.py", "graphql/"],
+            "celery_tasks": ["tasks.py", "celery.py", "workers/"],
+            "testing_pattern": ["tests/", "test_*.py", "conftest.py"],
+            "documentation": ["docs/", "README.md", "*.rst"],
+            "containerization": ["Dockerfile", "docker-compose.yml", ".dockerignore"],
+            "ci_cd": [".github/", ".gitlab-ci.yml", "Jenkinsfile"],
+        }
+    
+    async def detect_patterns(
+        self,
+        request: ProjectScanRequest,
+        result: ScanResult,
+        dependencies: ServiceDependencies
+    ) -> None:
+        """Detect architectural patterns in the project."""
+        try:
+            patterns = []
+            
+            for pattern_name, indicators in self.pattern_indicators.items():
+                evidence = []
+                files_using_pattern = []
+                
+                for indicator in indicators:
+                    # Search for pattern indicators
+                    if indicator.endswith("/"):
+                        # Directory pattern
+                        for path in request.project_root.rglob(indicator.rstrip("/")):
+                            if path.is_dir():
+                                evidence.append(f"Directory: {path.relative_to(request.project_root)}")
+                                # Find files in this directory
+                                for file in path.rglob("*.py"):
+                                    files_using_pattern.append(str(file.relative_to(request.project_root)))
+                    else:
+                        # File pattern
+                        for path in request.project_root.rglob(indicator):
+                            if path.is_file():
+                                evidence.append(f"File: {path.relative_to(request.project_root)}")
+                                files_using_pattern.append(str(path.relative_to(request.project_root)))
+                
+                if evidence:
+                    # Calculate confidence based on evidence strength
+                    confidence = min(1.0, len(evidence) / 3.0)  # Max confidence with 3+ pieces of evidence
+                    
+                    pattern = ArchitecturalPattern(
+                        name=pattern_name,
+                        description=f"Detected {pattern_name.replace('_', ' ')} pattern",
+                        confidence=confidence,
+                        evidence=evidence[:10],  # Limit evidence list
+                        files_using_pattern=files_using_pattern[:20]  # Limit file list
+                    )
+                    patterns.append(pattern)
+            
+            result.architectural_patterns = patterns
+            
+        except Exception as e:
+            dependencies.log_error("Failed to detect patterns", e)
+    
+    def detect_django_version(self, apps: List[Any]) -> str:
+        """Detect Django version from project structure."""
+        # This is a placeholder - would need actual implementation
+        # based on Django features used in the codebase
+        return "5.0+"  # Default assumption for modern projects

django_cfg/modules/django_app_agent/services/questioning_service/__init__.py

@@ -0,0 +1,28 @@
+"""
+Intelligent Questioning Service for Django App Agent Module.
+
+This package orchestrates the intelligent questioning process by coordinating
+with specialized AI agents to generate context-aware questions based on
+project analysis and user requirements.
+"""
+
+from .main import QuestioningService
+from .models import (
+    QuestioningRequest, QuestioningResult, QuestioningSession,
+    ContextualQuestion, QuestionResponse
+)
+from .question_generator import QuestionGenerator
+from .response_processor import ResponseProcessor
+from .session_manager import SessionManager
+
+__all__ = [
+    "QuestioningService",
+    "QuestioningRequest",
+    "QuestioningResult",
+    "QuestioningSession",
+    "ContextualQuestion",
+    "QuestionResponse",
+    "QuestionGenerator",
+    "ResponseProcessor",
+    "SessionManager",
+]

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

@@ -0,0 +1,273 @@
+"""
+Main Intelligent Questioning Service for Django App Agent Module.
+
+This service orchestrates the intelligent questioning process by coordinating
+with specialized AI agents to generate context-aware questions based on
+project analysis and user requirements.
+"""
+
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from ...core.config import AgentConfig
+from ...models.context import ProjectContext
+from ..base import BaseService, ServiceDependencies
+from ..context_builder import ContextBuilderService, ContextBuildRequest
+from .models import QuestioningRequest, QuestioningResult, QuestioningSession, ContextualQuestion
+from .question_generator import QuestionGenerator
+from .response_processor import ResponseProcessor
+from .session_manager import SessionManager
+
+
+class QuestioningService(BaseService[QuestioningRequest, QuestioningResult]):
+    """
+    Intelligent questioning service for context-aware requirement gathering.
+    
+    This service:
+    1. Analyzes project context and user intent
+    2. Generates targeted questions using AI agents
+    3. Manages interactive questioning sessions
+    4. Processes responses to refine generation requests
+    5. Provides insights and recommendations
+    """
+    
+    def __init__(self, config: AgentConfig):
+        """Initialize questioning service."""
+        super().__init__("questioning", config)
+        self.config = config
+        
+        # Initialize components
+        self.context_builder = ContextBuilderService(config)
+        self.question_generator = QuestionGenerator(config=config)
+        self.response_processor = ResponseProcessor(config=config)
+        self.session_manager = SessionManager(config=config)
+    
+    async def process(
+        self,
+        request: QuestioningRequest,
+        dependencies: ServiceDependencies
+    ) -> QuestioningResult:
+        """
+        Process intelligent questioning request.
+        
+        Args:
+            request: Questioning request with user intent and project info
+            dependencies: Service dependencies
+            
+        Returns:
+            QuestioningResult with session and refined request
+        """
+        dependencies.log_operation(
+            "Starting intelligent questioning process",
+            user_intent=request.user_intent,
+            project_root=str(request.project_root),
+            max_questions=request.max_questions
+        )
+        
+        try:
+            # 1. Build comprehensive project context
+            project_context = await self._build_project_context(request, dependencies)
+            
+            # 2. Generate context-aware questions using AI agents
+            questions = await self.question_generator.generate_questions(
+                request, project_context, dependencies
+            )
+            
+            # 3. Create questioning session
+            session = await self.session_manager.create_session(
+                request, questions, project_context, dependencies
+            )
+            
+            # 4. For this implementation, we'll simulate the questioning process
+            # In a real implementation, this would be interactive
+            simulated_session = await self._simulate_questioning_process(
+                session, dependencies
+            )
+            
+            # 5. Process responses and build refined request
+            refined_request = await self.response_processor.process_responses(
+                simulated_session, dependencies
+            )
+            
+            # 6. Gather AI insights
+            insights = await self.session_manager.gather_agent_insights(
+                simulated_session, dependencies
+            )
+            
+            # 7. Calculate confidence score
+            confidence_score = self.session_manager.calculate_confidence_score(simulated_session)
+            
+            # 8. Generate recommendations
+            recommendations = self._generate_recommendations(simulated_session, insights)
+            
+            result = QuestioningResult(
+                session=simulated_session,
+                refined_request=refined_request,
+                confidence_score=confidence_score,
+                insights=insights,
+                recommendations=recommendations
+            )
+            
+            dependencies.log_operation(
+                "Questioning process completed",
+                session_id=simulated_session.session_id,
+                confidence_score=confidence_score,
+                refined_app_name=refined_request.app_name,
+                features_count=len(refined_request.features)
+            )
+            
+            return result
+            
+        except Exception as e:
+            dependencies.log_error("Questioning process failed", e)
+            raise
+    
+    async def _build_project_context(
+        self,
+        request: QuestioningRequest,
+        dependencies: ServiceDependencies
+    ) -> ProjectContext:
+        """Build comprehensive project context for question generation."""
+        dependencies.log_operation("Building project context for questioning")
+        
+        # Create context build request
+        context_request = ContextBuildRequest(
+            project_root=request.project_root,
+            target_app_name=None,  # We don't have an app name yet
+            generation_request=request.generation_request,
+            include_code_samples=True,
+            max_context_size=30000,  # Smaller context for questioning
+            focus_areas=request.focus_areas
+        )
+        
+        # Build context using context builder service
+        context_result = await self.context_builder.process(context_request, dependencies)
+        
+        return context_result.project_context
+    
+    async def _simulate_questioning_process(
+        self,
+        session: QuestioningSession,
+        dependencies: ServiceDependencies
+    ) -> QuestioningSession:
+        """
+        Simulate the questioning process for demonstration.
+        
+        In a real implementation, this would be replaced by actual
+        user interaction through the UI.
+        """
+        dependencies.log_operation(
+            "Simulating questioning process",
+            session_id=session.session_id,
+            questions_count=len(session.questions)
+        )
+        
+        # Simulate responses based on question types and user intent
+        for question in session.questions[:min(5, len(session.questions))]:  # Limit to 5 questions for demo
+            simulated_answer = self._generate_simulated_answer(question, session.user_intent)
+            confidence = self._calculate_simulated_confidence(question, simulated_answer)
+            
+            # Add response to session
+            await self.session_manager.add_response(
+                session.session_id,
+                question.id,
+                simulated_answer,
+                confidence,
+                dependencies
+            )
+        
+        # Mark session as completed
+        await self.session_manager.complete_session(session.session_id, dependencies)
+        
+        return session
+    
+    def _generate_simulated_answer(
+        self,
+        question: ContextualQuestion,
+        user_intent: str
+    ) -> str:
+        """Generate simulated answer based on question and user intent."""
+        intent_lower = user_intent.lower()
+        question_lower = question.text.lower()
+        
+        # Generate contextual answers based on question type
+        if question.question_type == "yes_no":
+            # Determine yes/no based on question content and user intent
+            if any(word in question_lower for word in ["auth", "login", "user"]):
+                return "yes" if any(word in intent_lower for word in ["user", "auth", "login"]) else "no"
+            elif any(word in question_lower for word in ["api", "integration"]):
+                return "yes" if any(word in intent_lower for word in ["api", "integration", "external"]) else "no"
+            elif any(word in question_lower for word in ["admin", "management"]):
+                return "yes" if any(word in intent_lower for word in ["admin", "manage", "dashboard"]) else "no"
+            else:
+                return "yes"  # Default to yes for other questions
+        
+        elif question.question_type == "choice" and question.options:
+            # Select most relevant option based on user intent
+            for option in question.options:
+                if any(word in option.lower() for word in intent_lower.split()):
+                    return option
+            return question.options[0]  # Default to first option
+        
+        else:  # text question
+            # Generate contextual text response
+            if "purpose" in question_lower:
+                return f"Application for {user_intent}"
+            elif "data" in question_lower:
+                return "Business data and user information"
+            elif "users" in question_lower:
+                return "Small to medium team (10-50 users)"
+            else:
+                return f"Based on the requirement: {user_intent}"
+    
+    def _calculate_simulated_confidence(
+        self,
+        question: ContextualQuestion,
+        answer: str
+    ) -> float:
+        """Calculate simulated confidence score."""
+        # Higher confidence for specific answers, lower for generic ones
+        if question.question_type == "yes_no":
+            return 0.9
+        elif question.question_type == "choice":
+            return 0.8
+        elif len(answer) > 20:  # Detailed text answer
+            return 0.7
+        else:
+            return 0.6
+    
+    def _generate_recommendations(
+        self,
+        session: QuestioningSession,
+        insights: Dict[str, Any]
+    ) -> List[str]:
+        """Generate development recommendations based on session and insights."""
+        recommendations = []
+        
+        # Add recommendations from insights
+        if "recommendations" in insights:
+            recommendations.extend(insights["recommendations"])
+        
+        # Add confidence-based recommendations
+        confidence_score = self.session_manager.calculate_confidence_score(session)
+        
+        if confidence_score > 0.8:
+            recommendations.append("High confidence in requirements - proceed with development")
+        elif confidence_score > 0.6:
+            recommendations.append("Moderate confidence - consider prototype or MVP approach")
+        else:
+            recommendations.append("Low confidence - additional requirement gathering recommended")
+        
+        # Add architectural recommendations based on patterns
+        if insights.get("pattern_detection", {}).get("api_focused"):
+            recommendations.append("Consider API-first architecture with comprehensive serializers")
+        
+        if insights.get("pattern_detection", {}).get("user_centric"):
+            recommendations.append("Implement robust authentication and user management features")
+        
+        if insights.get("pattern_detection", {}).get("data_intensive"):
+            recommendations.append("Focus on efficient data models and database optimization")
+        
+        return recommendations[:5]  # Limit to top 5 recommendations

django_cfg/modules/django_app_agent/services/questioning_service/models.py

@@ -0,0 +1,111 @@
+"""
+Data Models for Intelligent Questioning Service.
+
+This module defines the data structures used by the questioning service
+for managing context-aware question generation and user interactions.
+"""
+
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+from datetime import datetime, timezone
+
+from pydantic import BaseModel, Field, ConfigDict
+
+from ...models.requests import AppGenerationRequest
+from ...models.context import ProjectContext
+
+
+class QuestioningRequest(BaseModel):
+    """Request for intelligent questioning session."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    user_intent: str = Field(description="User's stated intent or requirement")
+    project_root: Path = Field(description="Root directory of the project")
+    generation_request: Optional[AppGenerationRequest] = Field(default=None, description="Initial generation request")
+    max_questions: int = Field(default=20, ge=1, le=30, description="Maximum number of questions to ask")
+    focus_areas: List[str] = Field(default_factory=list, description="Areas to focus questioning on")
+
+
+class ContextualQuestion(BaseModel):
+    """Represents a context-aware question generated by AI agents."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    id: str = Field(description="Unique question identifier")
+    text: str = Field(description="The question text")
+    question_type: str = Field(description="Type of question (yes_no, choice, text, etc.)")
+    priority: int = Field(ge=1, le=10, description="Question priority (1=highest, 10=lowest)")
+    impact_level: str = Field(description="Impact level (low, medium, high, critical)")
+    
+    # Context information
+    context_evidence: List[str] = Field(default_factory=list, description="Evidence from project analysis")
+    architectural_implications: List[str] = Field(default_factory=list, description="Architectural implications")
+    
+    # Question options (for choice questions)
+    options: Optional[List[str]] = Field(default=None, description="Available options for choice questions")
+    default_value: Optional[str] = Field(default=None, description="Default/suggested value")
+    
+    # Metadata
+    generated_by: str = Field(description="AI agent that generated this question")
+    generation_reasoning: str = Field(description="Reasoning behind question generation")
+
+
+class QuestionResponse(BaseModel):
+    """User's response to a contextual question."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    question_id: str = Field(description="ID of the question being answered")
+    answer: str = Field(description="User's answer")
+    confidence: float = Field(ge=0.0, le=1.0, description="User's confidence in their answer")
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+class QuestioningSession(BaseModel):
+    """Represents an active questioning session."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    session_id: str = Field(description="Unique session identifier")
+    questions: List[ContextualQuestion] = Field(description="Generated questions")
+    responses: List[QuestionResponse] = Field(default_factory=list, description="User responses")
+    project_context: ProjectContext = Field(description="Project analysis context")
+    
+    # Session metadata
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    completed_at: Optional[datetime] = Field(default=None)
+    user_intent: str = Field(description="Original user intent")
+    
+    # Progress tracking
+    current_question_index: int = Field(default=0, description="Index of current question")
+    is_completed: bool = Field(default=False, description="Whether session is completed")
+    
+    @property
+    def completion_percentage(self) -> float:
+        """Calculate completion percentage."""
+        if not self.questions:
+            return 0.0
+        return len(self.responses) / len(self.questions) * 100
+    
+    @property
+    def answered_questions(self) -> int:
+        """Count of answered questions."""
+        return len(self.responses)
+    
+    @property
+    def remaining_questions(self) -> int:
+        """Count of remaining questions."""
+        return len(self.questions) - len(self.responses)
+
+
+class QuestioningResult(BaseModel):
+    """Result of intelligent questioning process."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    session: QuestioningSession = Field(description="Completed questioning session")
+    refined_request: AppGenerationRequest = Field(description="Refined generation request based on answers")
+    confidence_score: float = Field(ge=0.0, le=1.0, description="Confidence in the refined request")
+    insights: Dict[str, Any] = Field(default_factory=dict, description="AI-generated insights from responses")
+    recommendations: List[str] = Field(default_factory=list, description="Development recommendations")