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

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

@@ -0,0 +1,356 @@
+"""
+Session Manager for Intelligent Questioning Service.
+
+This module manages questioning sessions, including creation,
+progress tracking, and completion handling.
+"""
+
+from typing import List, Dict, Any, Optional
+import uuid
+from datetime import datetime, timezone
+
+from pydantic import BaseModel, Field
+
+from ...core.config import AgentConfig
+from ...models.context import ProjectContext
+from ..base import ServiceDependencies
+from .models import (
+    QuestioningRequest, QuestioningSession, ContextualQuestion,
+    QuestionResponse, QuestioningResult
+)
+
+
+class SessionManager(BaseModel):
+    """Manages questioning sessions and their lifecycle."""
+    
+    config: AgentConfig = Field(description="Agent configuration")
+    
+    # Session storage (in production, this would be a database)
+    active_sessions: Dict[str, QuestioningSession] = Field(
+        default_factory=dict,
+        description="Active questioning sessions"
+    )
+
+    async def create_session(
+        self,
+        request: QuestioningRequest,
+        questions: List[ContextualQuestion],
+        project_context: ProjectContext,
+        dependencies: ServiceDependencies
+    ) -> QuestioningSession:
+        """Create a new questioning session."""
+        session_id = str(uuid.uuid4())
+        
+        session = QuestioningSession(
+            session_id=session_id,
+            questions=questions,
+            project_context=project_context,
+            user_intent=request.user_intent,
+            created_at=datetime.now(timezone.utc)
+        )
+        
+        # Store session
+        self.active_sessions[session_id] = session
+        
+        dependencies.log_operation(
+            "Questioning session created",
+            session_id=session_id,
+            questions_count=len(questions),
+            user_intent=request.user_intent
+        )
+        
+        return session
+    
+    async def add_response(
+        self,
+        session_id: str,
+        question_id: str,
+        answer: str,
+        confidence: float,
+        dependencies: ServiceDependencies
+    ) -> Optional[QuestioningSession]:
+        """Add a response to an existing session."""
+        session = self.active_sessions.get(session_id)
+        if not session:
+            dependencies.log_error(f"Session not found: {session_id}")
+            return None
+        
+        # Validate question exists
+        question = self._find_question_by_id(session.questions, question_id)
+        if not question:
+            dependencies.log_error(f"Question not found: {question_id}")
+            return None
+        
+        # Create response
+        response = QuestionResponse(
+            question_id=question_id,
+            answer=answer,
+            confidence=confidence,
+            timestamp=datetime.now(timezone.utc)
+        )
+        
+        # Add to session
+        session.responses.append(response)
+        session.current_question_index = len(session.responses)
+        
+        # Check if session is completed
+        if len(session.responses) >= len(session.questions):
+            session.is_completed = True
+            session.completed_at = datetime.now(timezone.utc)
+        
+        dependencies.log_operation(
+            "Response added to session",
+            session_id=session_id,
+            question_id=question_id,
+            completion_percentage=session.completion_percentage,
+            is_completed=session.is_completed
+        )
+        
+        return session
+    
+    async def get_session(
+        self,
+        session_id: str,
+        dependencies: ServiceDependencies
+    ) -> Optional[QuestioningSession]:
+        """Get an existing session."""
+        session = self.active_sessions.get(session_id)
+        
+        if not session:
+            dependencies.log_error(f"Session not found: {session_id}")
+        
+        return session
+    
+    async def get_next_question(
+        self,
+        session_id: str,
+        dependencies: ServiceDependencies
+    ) -> Optional[ContextualQuestion]:
+        """Get the next unanswered question in a session."""
+        session = self.active_sessions.get(session_id)
+        if not session:
+            return None
+        
+        if session.is_completed:
+            return None
+        
+        # Find next unanswered question
+        answered_question_ids = {r.question_id for r in session.responses}
+        
+        for question in session.questions:
+            if question.id not in answered_question_ids:
+                return question
+        
+        return None
+    
+    async def complete_session(
+        self,
+        session_id: str,
+        dependencies: ServiceDependencies
+    ) -> Optional[QuestioningSession]:
+        """Mark a session as completed."""
+        session = self.active_sessions.get(session_id)
+        if not session:
+            return None
+        
+        session.is_completed = True
+        session.completed_at = datetime.now(timezone.utc)
+        
+        dependencies.log_operation(
+            "Session completed",
+            session_id=session_id,
+            total_responses=len(session.responses),
+            completion_percentage=session.completion_percentage
+        )
+        
+        return session
+    
+    async def cleanup_session(
+        self,
+        session_id: str,
+        dependencies: ServiceDependencies
+    ) -> bool:
+        """Remove a session from active sessions."""
+        if session_id in self.active_sessions:
+            del self.active_sessions[session_id]
+            dependencies.log_operation(f"Session cleaned up: {session_id}")
+            return True
+        
+        return False
+    
+    def calculate_confidence_score(
+        self,
+        session: QuestioningSession
+    ) -> float:
+        """Calculate overall confidence score for a session."""
+        if not session.responses:
+            return 0.0
+        
+        # Weight confidence by question impact
+        impact_weights = {"critical": 1.0, "high": 0.8, "medium": 0.6, "low": 0.4}
+        
+        weighted_confidence = 0.0
+        total_weight = 0.0
+        
+        for response in session.responses:
+            question = self._find_question_by_id(session.questions, response.question_id)
+            if question:
+                weight = impact_weights.get(question.impact_level, 0.6)
+                weighted_confidence += response.confidence * weight
+                total_weight += weight
+        
+        return weighted_confidence / total_weight if total_weight > 0 else 0.0
+    
+    async def gather_agent_insights(
+        self,
+        session: QuestioningSession,
+        dependencies: ServiceDependencies
+    ) -> Dict[str, Any]:
+        """Gather insights from AI agents based on session responses."""
+        insights = {
+            "response_analysis": {},
+            "pattern_detection": {},
+            "recommendations": [],
+            "confidence_assessment": {}
+        }
+        
+        try:
+            # Analyze response patterns
+            insights["response_analysis"] = self._analyze_response_patterns(session)
+            
+            # Detect architectural patterns
+            insights["pattern_detection"] = self._detect_architectural_patterns(session)
+            
+            # Generate recommendations
+            insights["recommendations"] = self._generate_recommendations(session)
+            
+            # Assess confidence
+            insights["confidence_assessment"] = {
+                "overall_confidence": self.calculate_confidence_score(session),
+                "low_confidence_areas": self._identify_low_confidence_areas(session),
+                "high_confidence_areas": self._identify_high_confidence_areas(session)
+            }
+            
+        except Exception as e:
+            dependencies.log_error("Failed to gather agent insights", e)
+        
+        return insights
+    
+    def _find_question_by_id(
+        self,
+        questions: List[ContextualQuestion],
+        question_id: str
+    ) -> Optional[ContextualQuestion]:
+        """Find question by ID."""
+        for question in questions:
+            if question.id == question_id:
+                return question
+        return None
+    
+    def _analyze_response_patterns(
+        self,
+        session: QuestioningSession
+    ) -> Dict[str, Any]:
+        """Analyze patterns in user responses."""
+        patterns = {
+            "response_length_avg": 0.0,
+            "confidence_avg": 0.0,
+            "yes_no_ratio": 0.0,
+            "detailed_responses": 0
+        }
+        
+        if not session.responses:
+            return patterns
+        
+        # Calculate averages
+        total_length = sum(len(r.answer) for r in session.responses)
+        total_confidence = sum(r.confidence for r in session.responses)
+        
+        patterns["response_length_avg"] = total_length / len(session.responses)
+        patterns["confidence_avg"] = total_confidence / len(session.responses)
+        
+        # Count yes/no responses
+        yes_no_count = sum(
+            1 for r in session.responses 
+            if r.answer.lower() in ["yes", "no", "y", "n", "true", "false"]
+        )
+        patterns["yes_no_ratio"] = yes_no_count / len(session.responses)
+        
+        # Count detailed responses (>20 characters)
+        patterns["detailed_responses"] = sum(
+            1 for r in session.responses if len(r.answer) > 20
+        )
+        
+        return patterns
+    
+    def _detect_architectural_patterns(
+        self,
+        session: QuestioningSession
+    ) -> Dict[str, Any]:
+        """Detect architectural patterns from responses."""
+        patterns = {
+            "api_focused": False,
+            "admin_heavy": False,
+            "user_centric": False,
+            "data_intensive": False
+        }
+        
+        # Analyze responses for architectural indicators
+        all_answers = " ".join(r.answer.lower() for r in session.responses)
+        
+        patterns["api_focused"] = "api" in all_answers or "integration" in all_answers
+        patterns["admin_heavy"] = "admin" in all_answers or "management" in all_answers
+        patterns["user_centric"] = "user" in all_answers or "authentication" in all_answers
+        patterns["data_intensive"] = "data" in all_answers or "database" in all_answers
+        
+        return patterns
+    
+    def _generate_recommendations(
+        self,
+        session: QuestioningSession
+    ) -> List[str]:
+        """Generate development recommendations based on responses."""
+        recommendations = []
+        
+        # Analyze confidence levels
+        avg_confidence = sum(r.confidence for r in session.responses) / len(session.responses) if session.responses else 0
+        
+        if avg_confidence < 0.7:
+            recommendations.append("Consider additional planning phase due to low confidence in requirements")
+        
+        # Analyze response patterns
+        detailed_count = sum(1 for r in session.responses if len(r.answer) > 50)
+        if detailed_count > len(session.responses) * 0.7:
+            recommendations.append("User provided detailed requirements - consider iterative development approach")
+        
+        return recommendations
+    
+    def _identify_low_confidence_areas(
+        self,
+        session: QuestioningSession
+    ) -> List[str]:
+        """Identify areas where user expressed low confidence."""
+        low_confidence_areas = []
+        
+        for response in session.responses:
+            if response.confidence < 0.6:
+                question = self._find_question_by_id(session.questions, response.question_id)
+                if question:
+                    low_confidence_areas.append(question.text)
+        
+        return low_confidence_areas
+    
+    def _identify_high_confidence_areas(
+        self,
+        session: QuestioningSession
+    ) -> List[str]:
+        """Identify areas where user expressed high confidence."""
+        high_confidence_areas = []
+        
+        for response in session.responses:
+            if response.confidence > 0.8:
+                question = self._find_question_by_id(session.questions, response.question_id)
+                if question:
+                    high_confidence_areas.append(question.text)
+        
+        return high_confidence_areas

django_cfg/modules/django_app_agent/services/report_service.py

@@ -0,0 +1,332 @@
+"""
+Report Service for Django App Agent Module.
+
+This service generates comprehensive reports for application generation
+processes, including detailed logs, metrics, and documentation.
+"""
+
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+from datetime import datetime, timezone
+import json
+
+from pydantic import BaseModel, Field, ConfigDict
+
+from .base import BaseService, ServiceDependencies
+from ..models.responses import AppGenerationResult, QualityMetrics, GeneratedFile
+from ..core.exceptions import FileSystemError
+
+
+class ReportRequest(BaseModel):
+    """Request for report generation."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    generation_result: AppGenerationResult = Field(description="Application generation result")
+    report_formats: List[str] = Field(
+        default_factory=lambda: ["markdown", "json"],
+        description="Report formats to generate"
+    )
+    include_code_samples: bool = Field(default=True, description="Whether to include code samples")
+    include_metrics: bool = Field(default=True, description="Whether to include quality metrics")
+    output_directory: Optional[Path] = Field(default=None, description="Custom output directory")
+
+
+class ReportResult(BaseModel):
+    """Result of report generation."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    generated_reports: List[str] = Field(description="Paths to generated report files")
+    report_summary: Dict[str, Any] = Field(description="Summary of the report generation")
+    total_size_bytes: int = Field(default=0, description="Total size of generated reports")
+
+
+class ReportService(BaseService[ReportRequest, ReportResult]):
+    """
+    Service for generating comprehensive reports of application generation processes.
+    
+    Provides:
+    - Markdown reports with detailed information
+    - JSON reports for programmatic access
+    - Code sample inclusion
+    - Quality metrics visualization
+    - Process documentation
+    """
+    
+    def __init__(self, config):
+        """Initialize report service."""
+        super().__init__("report", config)
+    
+    async def process(
+        self, 
+        request: ReportRequest, 
+        dependencies: ServiceDependencies
+    ) -> ReportResult:
+        """
+        Process report generation request.
+        
+        Args:
+            request: Report generation request
+            dependencies: Service dependencies
+            
+        Returns:
+            ReportResult with generated reports
+        """
+        dependencies.log_operation(
+            f"Generating reports for app '{request.generation_result.app_name}'",
+            formats=request.report_formats,
+            include_code_samples=request.include_code_samples,
+            include_metrics=request.include_metrics
+        )
+        
+        try:
+            generated_reports = []
+            total_size = 0
+            
+            # Determine output directory
+            output_dir = request.output_directory or dependencies.get_output_path()
+            report_dir = output_dir / request.generation_result.app_name / "@report"
+            report_dir.mkdir(parents=True, exist_ok=True)
+            
+            # Generate reports in requested formats
+            for format_type in request.report_formats:
+                if format_type == "markdown":
+                    report_path = await self._generate_markdown_report(
+                        request, report_dir, dependencies
+                    )
+                elif format_type == "json":
+                    report_path = await self._generate_json_report(
+                        request, report_dir, dependencies
+                    )
+                else:
+                    dependencies.logger.warning(f"Unknown report format: {format_type}")
+                    continue
+                
+                if report_path and report_path.exists():
+                    generated_reports.append(str(report_path))
+                    total_size += report_path.stat().st_size
+            
+            # Generate summary
+            summary = {
+                "app_name": request.generation_result.app_name,
+                "generation_status": request.generation_result.status,
+                "reports_generated": len(generated_reports),
+                "formats": request.report_formats,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "total_files_generated": len(request.generation_result.generated_files)
+            }
+            
+            result = ReportResult(
+                generated_reports=generated_reports,
+                report_summary=summary,
+                total_size_bytes=total_size
+            )
+            
+            dependencies.log_operation(
+                "Report generation completed successfully",
+                reports_count=len(generated_reports),
+                total_size_kb=total_size // 1024
+            )
+            
+            return result
+            
+        except Exception as e:
+            dependencies.log_error("Report generation failed", e)
+            raise
+    
+    async def _generate_markdown_report(
+        self,
+        request: ReportRequest,
+        output_dir: Path,
+        dependencies: ServiceDependencies
+    ) -> Optional[Path]:
+        """Generate markdown report."""
+        try:
+            result = request.generation_result
+            report_path = output_dir / "GENERATION_REPORT.md"
+            
+            # Build markdown content
+            content = self._build_markdown_content(request, dependencies)
+            
+            # Write report
+            report_path.write_text(content, encoding='utf-8')
+            
+            return report_path
+            
+        except Exception as e:
+            dependencies.log_error("Failed to generate markdown report", e)
+            return None
+    
+    async def _generate_json_report(
+        self,
+        request: ReportRequest,
+        output_dir: Path,
+        dependencies: ServiceDependencies
+    ) -> Optional[Path]:
+        """Generate JSON report."""
+        try:
+            result = request.generation_result
+            report_path = output_dir / "generation_report.json"
+            
+            # Build JSON data
+            report_data = {
+                "metadata": {
+                    "generated_at": datetime.now(timezone.utc).isoformat(),
+                    "generator_version": "0.1.0",
+                    "report_format": "json"
+                },
+                "application": {
+                    "name": result.app_name,
+                    "status": result.status,
+                    "message": result.message,
+                    "duration_seconds": result.duration_seconds
+                },
+                "generation_process": {
+                    "files_generated": len(result.generated_files),
+                    "errors": result.errors,
+                    "warnings": result.warnings,
+                    "ai_dialogue_log": result.ai_dialogue_log if request.include_code_samples else []
+                },
+                "quality_metrics": result.quality_metrics.model_dump() if result.quality_metrics and request.include_metrics else None,
+                "generated_files": [
+                    {
+                        "path": f.path,
+                        "type": f.file_type,
+                        "description": f.description,
+                        "size_bytes": f.size_bytes,
+                        "content": f.content if request.include_code_samples else None
+                    }
+                    for f in result.generated_files
+                ]
+            }
+            
+            # Write JSON report
+            with open(report_path, 'w', encoding='utf-8') as f:
+                json.dump(report_data, f, indent=2, ensure_ascii=False)
+            
+            return report_path
+            
+        except Exception as e:
+            dependencies.log_error("Failed to generate JSON report", e)
+            return None
+    
+    def _build_markdown_content(
+        self,
+        request: ReportRequest,
+        dependencies: ServiceDependencies
+    ) -> str:
+        """Build markdown report content."""
+        result = request.generation_result
+        
+        content = f"""# Application Generation Report
+
+## 📋 Summary
+
+**Application Name**: `{result.app_name}`  
+**Status**: {result.status.upper()}  
+**Generated**: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}  
+**Duration**: {result.duration_seconds:.2f} seconds  
+
+{result.message}
+
+## 📊 Generation Statistics
+
+- **Files Generated**: {len(result.generated_files)}
+- **Errors**: {len(result.errors)}
+- **Warnings**: {len(result.warnings)}
+
+"""
+        
+        # Add errors section if any
+        if result.errors:
+            content += "## ❌ Errors\n\n"
+            for error in result.errors:
+                content += f"- {error}\n"
+            content += "\n"
+        
+        # Add warnings section if any
+        if result.warnings:
+            content += "## ⚠️ Warnings\n\n"
+            for warning in result.warnings:
+                content += f"- {warning}\n"
+            content += "\n"
+        
+        # Add quality metrics if available and requested
+        if result.quality_metrics and request.include_metrics:
+            metrics = result.quality_metrics
+            content += f"""## 📈 Quality Metrics
+
+- **Code Readability**: {metrics.code_readability_score:.2f}/1.0
+- **Maintainability**: {metrics.maintainability_score:.2f}/1.0
+- **Type Hint Completeness**: {metrics.type_hint_completeness:.2f}/1.0
+- **Pydantic Compliance**: {metrics.pydantic_compliance_score:.2f}/1.0
+- **Test Coverage**: {metrics.test_coverage_percentage:.1f}%
+- **Security Vulnerabilities**: {metrics.security_vulnerabilities_found}
+- **Performance Issues**: {metrics.performance_bottlenecks_found}
+
+"""
+        
+        # Add generated files section
+        content += "## 📁 Generated Files\n\n"
+        
+        # Group files by type
+        files_by_type = {}
+        for file in result.generated_files:
+            file_type = file.file_type
+            if file_type not in files_by_type:
+                files_by_type[file_type] = []
+            files_by_type[file_type].append(file)
+        
+        for file_type, files in files_by_type.items():
+            content += f"### {file_type.title()} Files\n\n"
+            for file in files:
+                content += f"- **{file.path}**"
+                if file.description:
+                    content += f" - {file.description}"
+                content += f" ({file.size_bytes} bytes)\n"
+            content += "\n"
+        
+        # Add code samples if requested
+        if request.include_code_samples and result.generated_files:
+            content += "## 💻 Code Samples\n\n"
+            
+            # Show a few key files
+            key_files = [f for f in result.generated_files if f.file_type == "python"][:3]
+            
+            for file in key_files:
+                content += f"### {file.path}\n\n"
+                if file.description:
+                    content += f"{file.description}\n\n"
+                
+                content += f"```python\n{file.content}\n```\n\n"
+        
+        # Add AI dialogue log if available and requested
+        if result.ai_dialogue_log and request.include_code_samples:
+            content += "## 🤖 AI Generation Process\n\n"
+            
+            for entry in result.ai_dialogue_log:
+                agent = entry.get("agent", "Unknown")
+                timestamp = entry.get("timestamp", "")
+                output = entry.get("output", {})
+                
+                content += f"### {agent} Agent\n\n"
+                content += f"**Timestamp**: {timestamp}\n\n"
+                
+                if isinstance(output, dict):
+                    for key, value in output.items():
+                        content += f"- **{key}**: {value}\n"
+                else:
+                    content += f"Output: {output}\n"
+                
+                content += "\n"
+        
+        # Add footer
+        content += f"""---
+
+**Report Generated**: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}  
+**Generator**: Django App Agent v0.1.0  
+**Format**: Markdown
+"""
+        
+        return content

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

@@ -0,0 +1,18 @@
+"""
+Template Manager Service for Django App Agent Module.
+
+This package provides sophisticated Jinja2-based template rendering
+with feature-driven code generation capabilities.
+"""
+
+from .main import TemplateManagerService
+from .jinja_engine import JinjaTemplateEngine
+from .template_loader import TemplateLoader
+from .variable_processor import VariableProcessor
+
+__all__ = [
+    "TemplateManagerService",
+    "JinjaTemplateEngine",
+    "TemplateLoader", 
+    "VariableProcessor",
+]