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

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

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

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

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

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

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