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

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

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

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

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