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

django_cfg/modules/django_app_agent/agents/base/executor.py

@@ -0,0 +1,430 @@
+"""
+Agent execution management for Django App Agent Module.
+
+This module provides execution management and orchestration for AI agents,
+including result handling, error management, and performance tracking.
+"""
+
+from typing import TypeVar, Generic, Optional, Dict, Any, List, Union, Callable, Awaitable
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+import asyncio
+
+from pydantic import BaseModel, Field, ConfigDict
+
+from ...core.config import AgentConfig
+from ...core.exceptions import AgentExecutionError, ValidationError
+from ...models.base import TimestampedModel
+from ...utils.logging import StructuredLogger, get_logger
+from .context import AgentDependencies, AgentContext
+from .agent import DjangoAgent
+
+# Type variables
+OutputT = TypeVar('OutputT')
+DepsT = TypeVar('DepsT', bound=AgentDependencies)
+
+
+class ExecutionStatus(str, Enum):
+    """Status of agent execution."""
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class ExecutionResult(BaseModel, Generic[OutputT]):
+    """Result of agent execution."""
+    
+    model_config = ConfigDict(
+        extra='forbid',
+        validate_assignment=True,
+        arbitrary_types_allowed=True
+    )
+    
+    # Execution metadata
+    execution_id: str = Field(description="Unique execution identifier")
+    agent_name: str = Field(description="Name of the agent that was executed")
+    status: ExecutionStatus = Field(description="Execution status")
+    
+    # Timing information
+    start_time: datetime = Field(description="Execution start time")
+    end_time: Optional[datetime] = Field(default=None, description="Execution end time")
+    
+    # Results
+    output: Optional[OutputT] = Field(default=None, description="Agent output")
+    error: Optional[str] = Field(default=None, description="Error message if failed")
+    
+    # Performance metrics
+    execution_time_seconds: float = Field(default=0.0, description="Total execution time")
+    token_usage: Dict[str, int] = Field(default_factory=dict, description="Token usage by provider")
+    api_calls_count: int = Field(default=0, description="Number of API calls made")
+    
+    # Context information
+    correlation_id: str = Field(description="Correlation ID for tracing")
+    operation_name: str = Field(description="Name of the operation")
+    
+    @property
+    def is_successful(self) -> bool:
+        """Check if execution was successful."""
+        return self.status == ExecutionStatus.COMPLETED and self.output is not None
+    
+    @property
+    def is_failed(self) -> bool:
+        """Check if execution failed."""
+        return self.status == ExecutionStatus.FAILED
+    
+    def get_summary(self) -> Dict[str, Any]:
+        """Get execution summary."""
+        return {
+            "execution_id": self.execution_id,
+            "agent_name": self.agent_name,
+            "status": self.status.value,
+            "is_successful": self.is_successful,
+            "execution_time_seconds": self.execution_time_seconds,
+            "total_tokens": sum(self.token_usage.values()),
+            "api_calls": self.api_calls_count,
+            "has_output": self.output is not None,
+            "has_error": self.error is not None,
+        }
+
+
+@dataclass
+class ExecutionPlan:
+    """Plan for executing multiple agents in sequence or parallel."""
+    
+    name: str
+    agents: List[DjangoAgent] = field(default_factory=list)
+    dependencies: Dict[str, List[str]] = field(default_factory=dict)
+    parallel_groups: List[List[str]] = field(default_factory=list)
+    timeout_seconds: float = 300.0
+    
+    def add_agent(self, agent: DjangoAgent, depends_on: Optional[List[str]] = None) -> None:
+        """Add agent to execution plan."""
+        self.agents.append(agent)
+        if depends_on:
+            self.dependencies[agent.agent_name] = depends_on
+    
+    def add_parallel_group(self, agent_names: List[str]) -> None:
+        """Add group of agents that can run in parallel."""
+        self.parallel_groups.append(agent_names)
+    
+    def validate(self) -> List[str]:
+        """Validate execution plan."""
+        errors = []
+        agent_names = {agent.agent_name for agent in self.agents}
+        
+        # Check dependencies reference existing agents
+        for agent_name, deps in self.dependencies.items():
+            if agent_name not in agent_names:
+                errors.append(f"Agent '{agent_name}' in dependencies not found in plan")
+            
+            for dep in deps:
+                if dep not in agent_names:
+                    errors.append(f"Dependency '{dep}' for '{agent_name}' not found in plan")
+        
+        # Check parallel groups reference existing agents
+        for group in self.parallel_groups:
+            for agent_name in group:
+                if agent_name not in agent_names:
+                    errors.append(f"Agent '{agent_name}' in parallel group not found in plan")
+        
+        return errors
+
+
+class AgentExecutor:
+    """Executor for managing and running Django App Agent AI agents."""
+    
+    def __init__(self, config: AgentConfig):
+        """Initialize agent executor.
+        
+        Args:
+            config: Agent configuration
+        """
+        self.config = config
+        self.logger = get_logger("agent_executor")
+        self._active_executions: Dict[str, ExecutionResult] = {}
+    
+    async def execute_single(
+        self,
+        agent: DjangoAgent[DepsT, OutputT],
+        prompt: str,
+        deps: DepsT,
+        execution_id: Optional[str] = None,
+        timeout_seconds: Optional[float] = None
+    ) -> ExecutionResult[OutputT]:
+        """Execute a single agent.
+        
+        Args:
+            agent: Agent to execute
+            prompt: Input prompt
+            deps: Agent dependencies
+            execution_id: Optional execution ID
+            timeout_seconds: Optional timeout override
+            
+        Returns:
+            Execution result
+        """
+        import uuid
+        
+        if execution_id is None:
+            execution_id = str(uuid.uuid4())
+        
+        start_time = datetime.now(timezone.utc)
+        
+        # Create execution result
+        result = ExecutionResult[OutputT](
+            execution_id=execution_id,
+            agent_name=agent.agent_name,
+            status=ExecutionStatus.PENDING,
+            start_time=start_time,
+            correlation_id=deps.correlation_id,
+            operation_name=deps.operation_name
+        )
+        
+        # Track active execution
+        self._active_executions[execution_id] = result
+        
+        try:
+            # Update status to running
+            result.status = ExecutionStatus.RUNNING
+            
+            # Create execution context
+            context = AgentContext()
+            
+            # Determine timeout
+            timeout = timeout_seconds or 300.0
+            
+            self.logger.info(
+                f"Starting execution of agent {agent.agent_name}",
+                execution_id=execution_id,
+                agent_name=agent.agent_name,
+                timeout_seconds=timeout
+            )
+            
+            # Execute agent with timeout
+            output = await asyncio.wait_for(
+                agent.run(prompt, deps, context),
+                timeout=timeout
+            )
+            
+            # Update result with success
+            end_time = datetime.now(timezone.utc)
+            result.status = ExecutionStatus.COMPLETED
+            result.output = output
+            result.end_time = end_time
+            result.execution_time_seconds = (end_time - start_time).total_seconds()
+            result.token_usage = context.token_usage.copy()
+            result.api_calls_count = context.api_calls_count
+            
+            self.logger.info(
+                f"Completed execution of agent {agent.agent_name}",
+                execution_id=execution_id,
+                execution_time_seconds=result.execution_time_seconds,
+                success=True
+            )
+            
+            return result
+            
+        except asyncio.TimeoutError:
+            error_msg = f"Agent {agent.agent_name} execution timed out after {timeout} seconds"
+            result.status = ExecutionStatus.FAILED
+            result.error = error_msg
+            result.end_time = datetime.now(timezone.utc)
+            result.execution_time_seconds = (result.end_time - start_time).total_seconds()
+            
+            self.logger.error(
+                error_msg,
+                execution_id=execution_id,
+                agent_name=agent.agent_name,
+                timeout_seconds=timeout
+            )
+            
+            return result
+            
+        except Exception as e:
+            error_msg = f"Agent {agent.agent_name} execution failed: {e}"
+            result.status = ExecutionStatus.FAILED
+            result.error = error_msg
+            result.end_time = datetime.now(timezone.utc)
+            result.execution_time_seconds = (result.end_time - start_time).total_seconds()
+            
+            self.logger.error(
+                error_msg,
+                execution_id=execution_id,
+                agent_name=agent.agent_name,
+                error=str(e),
+                error_type=type(e).__name__
+            )
+            
+            return result
+            
+        finally:
+            # Remove from active executions
+            self._active_executions.pop(execution_id, None)
+    
+    async def execute_plan(
+        self,
+        plan: ExecutionPlan,
+        prompt: str,
+        deps: AgentDependencies,
+        execution_id: Optional[str] = None
+    ) -> Dict[str, ExecutionResult]:
+        """Execute multiple agents according to a plan.
+        
+        Args:
+            plan: Execution plan
+            prompt: Input prompt for all agents
+            deps: Base dependencies (will be copied for each agent)
+            execution_id: Optional execution ID
+            
+        Returns:
+            Dictionary mapping agent names to execution results
+        """
+        import uuid
+        
+        if execution_id is None:
+            execution_id = str(uuid.uuid4())
+        
+        # Validate plan
+        validation_errors = plan.validate()
+        if validation_errors:
+            raise ValidationError(
+                f"Invalid execution plan: {'; '.join(validation_errors)}",
+                validation_type="execution_plan"
+            )
+        
+        self.logger.info(
+            f"Starting execution plan '{plan.name}'",
+            execution_id=execution_id,
+            agents_count=len(plan.agents),
+            parallel_groups=len(plan.parallel_groups)
+        )
+        
+        results: Dict[str, ExecutionResult] = {}
+        agent_map = {agent.agent_name: agent for agent in plan.agents}
+        
+        try:
+            # Execute agents in dependency order
+            executed = set()
+            
+            while len(executed) < len(plan.agents):
+                # Find agents ready to execute (dependencies satisfied)
+                ready_agents = []
+                
+                for agent in plan.agents:
+                    if agent.agent_name in executed:
+                        continue
+                    
+                    # Check if dependencies are satisfied
+                    agent_deps = plan.dependencies.get(agent.agent_name, [])
+                    if all(dep in executed for dep in agent_deps):
+                        ready_agents.append(agent)
+                
+                if not ready_agents:
+                    # Check for circular dependencies
+                    remaining = [a.agent_name for a in plan.agents if a.agent_name not in executed]
+                    raise AgentExecutionError(
+                        f"Circular dependency detected or no agents ready to execute. Remaining: {remaining}",
+                        agent_name="executor",
+                        agent_operation="execute_plan"
+                    )
+                
+                # Execute ready agents (potentially in parallel)
+                tasks = []
+                for agent in ready_agents:
+                    # Create agent-specific dependencies
+                    agent_deps = AgentDependencies(
+                        config=deps.config,
+                        logger=deps.logger,
+                        project_context=deps.project_context,
+                        infrastructure_context=deps.infrastructure_context,
+                        correlation_id=f"{execution_id}_{agent.agent_name}",
+                        operation_name=f"{deps.operation_name}_{agent.agent_name}",
+                        project_root=deps.project_root,
+                        output_directory=deps.output_directory,
+                        execution_metadata=deps.execution_metadata.copy()
+                    )
+                    
+                    task = self.execute_single(
+                        agent,
+                        prompt,
+                        agent_deps,
+                        f"{execution_id}_{agent.agent_name}",
+                        plan.timeout_seconds
+                    )
+                    tasks.append((agent.agent_name, task))
+                
+                # Wait for all ready agents to complete
+                for agent_name, task in tasks:
+                    result = await task
+                    results[agent_name] = result
+                    executed.add(agent_name)
+                    
+                    if not result.is_successful:
+                        self.logger.warning(
+                            f"Agent {agent_name} failed in execution plan",
+                            execution_id=execution_id,
+                            error=result.error
+                        )
+            
+            self.logger.info(
+                f"Completed execution plan '{plan.name}'",
+                execution_id=execution_id,
+                successful_agents=sum(1 for r in results.values() if r.is_successful),
+                failed_agents=sum(1 for r in results.values() if r.is_failed)
+            )
+            
+            return results
+            
+        except Exception as e:
+            self.logger.error(
+                f"Execution plan '{plan.name}' failed",
+                execution_id=execution_id,
+                error=str(e),
+                error_type=type(e).__name__
+            )
+            raise
+    
+    def get_active_executions(self) -> Dict[str, ExecutionResult]:
+        """Get currently active executions."""
+        return self._active_executions.copy()
+    
+    def cancel_execution(self, execution_id: str) -> bool:
+        """Cancel an active execution.
+        
+        Args:
+            execution_id: ID of execution to cancel
+            
+        Returns:
+            True if execution was cancelled, False if not found
+        """
+        if execution_id in self._active_executions:
+            result = self._active_executions[execution_id]
+            result.status = ExecutionStatus.CANCELLED
+            result.end_time = datetime.now(timezone.utc)
+            result.execution_time_seconds = (result.end_time - result.start_time).total_seconds()
+            
+            self.logger.info(
+                f"Cancelled execution {execution_id}",
+                execution_id=execution_id,
+                agent_name=result.agent_name
+            )
+            
+            return True
+        
+        return False
+    
+    def get_execution_summary(self) -> Dict[str, Any]:
+        """Get summary of executor state."""
+        active = self.get_active_executions()
+        
+        return {
+            "active_executions_count": len(active),
+            "active_agents": [r.agent_name for r in active.values()],
+            "executor_config": {
+                "debug_mode": self.config.debug_mode,
+                "log_level": self.config.log_level.value,
+            }
+        }

django_cfg/modules/django_app_agent/agents/generation/__init__.py

@@ -0,0 +1,12 @@
+"""
+Code Generation Agents for Django App Agent Module.
+
+This module contains AI agents responsible for generating Django application code
+using Pydantic AI framework.
+"""
+
+from .app_generator import AppGeneratorAgent
+
+__all__ = [
+    "AppGeneratorAgent",
+]

django_cfg/modules/django_app_agent/agents/generation/app_generator/__init__.py

@@ -0,0 +1,15 @@
+"""
+Django Application Generator Agent Package.
+
+This package contains the decomposed components of the AI agent
+responsible for generating Django applications with intelligent code generation.
+"""
+
+from .main import AppGeneratorAgent
+from .models import FileGenerationRequest, GeneratedFileResponse
+
+__all__ = [
+    'AppGeneratorAgent',
+    'FileGenerationRequest', 
+    'GeneratedFileResponse'
+]

django_cfg/modules/django_app_agent/agents/generation/app_generator/config_validator.py

@@ -0,0 +1,147 @@
+"""
+Configuration validation for the App Generator Agent.
+
+This module handles API key validation and model configuration
+using django-cfg integration.
+"""
+
+import os
+from typing import Optional
+
+from pydantic_ai.models.openai import OpenAIModel
+
+from ....core.config import AgentConfig, AIProvider
+from ....core.exceptions import ConfigurationError
+
+
+class ConfigValidator:
+    """Validates and configures API keys and AI models."""
+    
+    def __init__(self):
+        """Initialize the config validator."""
+        self.model: Optional[OpenAIModel] = None
+    
+    def validate_and_configure(self, config) -> OpenAIModel:
+        """
+        Validate API keys and configure AI model.
+        
+        Args:
+            config: Configuration object (AgentConfig or other)
+            
+        Returns:
+            Configured OpenAI model
+            
+        Raises:
+            ConfigurationError: If no valid API keys found
+        """
+        try:
+            # Get configuration from django-cfg
+            print(f"🔍 Debug config type: {type(config)}")
+            print(f"🔍 Debug config: {config}")
+            
+            if isinstance(config, AgentConfig):
+                # Use provided AgentConfig
+                agent_config = config
+                print("✅ Using provided AgentConfig")
+            else:
+                # Load from django-cfg
+                print("🔄 Loading from django-cfg...")
+                agent_config = AgentConfig.from_django_cfg()
+                print(f"✅ Loaded AgentConfig: {type(agent_config)}")
+            
+            print(f"🔍 AgentConfig attributes: {dir(agent_config)}")
+            
+            # Get API keys from configuration
+            openai_key = self._get_api_key(agent_config, AIProvider.OPENAI)
+            openrouter_key = self._get_api_key(agent_config, AIProvider.OPENROUTER)
+            
+            print(f"🔍 API keys via get_api_key: OpenAI={bool(openai_key)}, OpenRouter={bool(openrouter_key)}")
+            
+            # Fallback to direct access
+            if not openai_key and not openrouter_key:
+                openai_key, openrouter_key = self._get_keys_direct_access(agent_config)
+            
+            # Debug: Print what we found
+            print(f"🔍 Final API Keys from django-cfg:")
+            print(f"  OpenAI: {'✅ Found' if openai_key else '❌ Missing'}")
+            print(f"  OpenRouter: {'✅ Found' if openrouter_key else '❌ Missing'}")
+            
+            if not openai_key and not openrouter_key:
+                raise ConfigurationError(
+                    "❌ AI Agent Configuration Error: No API keys found in django-cfg!\n\n"
+                    "🔑 Required: Either OpenAI or OpenRouter API key must be configured.\n\n"
+                    "📝 How to fix in django-cfg config:\n"
+                    "   api_keys:\n"
+                    "     openai: 'your-openai-key'\n"
+                    "     openrouter: 'your-openrouter-key'\n\n"
+                    "🚀 Without API keys, AI agents cannot generate intelligent code!\n"
+                    "   You'll only get basic template-based generation.",
+                    config_key="api_keys"
+                )
+            
+            # Configure and return the model
+            return self._configure_model(openai_key, openrouter_key)
+                
+        except Exception as e:
+            print(f"❌ Error loading API keys from django-cfg: {e}")
+            raise ConfigurationError(
+                f"Failed to load API keys from django-cfg configuration: {e}\n\n"
+                "🔧 Make sure django-cfg is properly configured with API keys.",
+                config_key="api_keys",
+                cause=e
+            )
+    
+    def _get_api_key(self, agent_config: AgentConfig, provider: AIProvider) -> Optional[str]:
+        """Get API key for specific provider."""
+        if hasattr(agent_config, 'get_api_key'):
+            return agent_config.get_api_key(provider)
+        return None
+    
+    def _get_keys_direct_access(self, agent_config: AgentConfig) -> tuple[Optional[str], Optional[str]]:
+        """Get API keys via direct access as fallback."""
+        openai_key = None
+        openrouter_key = None
+        
+        print("🔄 Trying direct access to api_keys...")
+        if hasattr(agent_config, 'api_keys') and agent_config.api_keys:
+            print(f"🔍 api_keys type: {type(agent_config.api_keys)}")
+            print(f"🔍 api_keys content: {agent_config.api_keys}")
+            
+            if hasattr(agent_config.api_keys, 'get'):
+                openai_key = agent_config.api_keys.get('openai', '')
+                openrouter_key = agent_config.api_keys.get('openrouter', '')
+            else:
+                openai_key = getattr(agent_config.api_keys, 'openai', '')
+                openrouter_key = getattr(agent_config.api_keys, 'openrouter', '')
+            
+            print(f"🔍 Direct access results: OpenAI={bool(openai_key)}, OpenRouter={bool(openrouter_key)}")
+        
+        return openai_key, openrouter_key
+    
+    def _configure_model(self, openai_key: Optional[str], openrouter_key: Optional[str]) -> OpenAIModel:
+        """Configure AI model with available API key."""
+        if openrouter_key:
+            print("🚀 Using OpenRouter API via django-cfg")
+            print(f"🔍 OpenRouter key length: {len(openrouter_key)}")
+            print(f"🔍 OpenRouter key prefix: {openrouter_key[:20]}...")
+            
+            # Set environment variables for OpenRouter
+            os.environ['OPENAI_API_KEY'] = openrouter_key
+            os.environ['OPENAI_BASE_URL'] = 'https://openrouter.ai/api/v1'
+            # OpenRouter требует специальные заголовки
+            os.environ['OPENAI_DEFAULT_HEADERS'] = '{"HTTP-Referer": "https://djangocfg.com", "X-Title": "Django CFG App Agent"}'
+            
+            self.model = OpenAIModel('gpt-4o-mini')
+            
+        elif openai_key:
+            print("🚀 Using OpenAI API via django-cfg")
+            
+            # Set environment variable for OpenAI
+            os.environ['OPENAI_API_KEY'] = openai_key
+            # Remove base URL for standard OpenAI
+            if 'OPENAI_BASE_URL' in os.environ:
+                del os.environ['OPENAI_BASE_URL']
+            
+            self.model = OpenAIModel('gpt-4o-mini')
+        
+        return self.model