django-cfg 1.1.81__py3-none-any.whl → 1.2.0__py3-none-any.whl

django_cfg/apps/agents/management/commands/create_agent.py

@@ -0,0 +1,365 @@
+"""
+Management command to create agent definitions.
+"""
+
+import asyncio
+from django.core.management.base import BaseCommand, CommandError
+from django.contrib.auth.models import User
+
+from django_cfg.modules.django_orchestrator.models.registry import AgentDefinition
+
+
+class Command(BaseCommand):
+    """Create agent definition from command line."""
+    
+    help = 'Create a new agent definition'
+    
+    def add_arguments(self, parser):
+        """Add command arguments."""
+        parser.add_argument('name', type=str, help='Agent name (unique identifier)')
+        parser.add_argument('instructions', type=str, help='Agent instructions/system prompt')
+        
+        parser.add_argument(
+            '--deps-type',
+            type=str,
+            default='DjangoDeps',
+            help='Dependencies type (default: DjangoDeps)'
+        )
+        parser.add_argument(
+            '--output-type',
+            type=str,
+            default='ProcessResult',
+            help='Output type (default: ProcessResult)'
+        )
+        parser.add_argument(
+            '--model',
+            type=str,
+            default='openai:gpt-4o-mini',
+            help='LLM model to use (default: openai:gpt-4o-mini)'
+        )
+        parser.add_argument(
+            '--category',
+            type=str,
+            default='',
+            help='Agent category'
+        )
+        parser.add_argument(
+            '--timeout',
+            type=int,
+            default=300,
+            help='Execution timeout in seconds (default: 300)'
+        )
+        parser.add_argument(
+            '--max-retries',
+            type=int,
+            default=3,
+            help='Maximum retry attempts (default: 3)'
+        )
+        parser.add_argument(
+            '--public',
+            action='store_true',
+            help='Make agent public (accessible to all users)'
+        )
+        parser.add_argument(
+            '--no-cache',
+            action='store_true',
+            help='Disable caching for this agent'
+        )
+        parser.add_argument(
+            '--creator',
+            type=str,
+            help='Username of agent creator (defaults to first superuser)'
+        )
+        parser.add_argument(
+            '--description',
+            type=str,
+            default='',
+            help='Agent description'
+        )
+        parser.add_argument(
+            '--tags',
+            type=str,
+            nargs='*',
+            help='Agent tags (space-separated)'
+        )
+    
+    def handle(self, *args, **options):
+        """Handle command execution."""
+        # Run async operations
+        asyncio.run(self._create_agent(options))
+    
+    async def _create_agent(self, options):
+        """Create agent definition."""
+        name = options['name']
+        instructions = options['instructions']
+        
+        # Validate name
+        if await AgentDefinition.objects.filter(name=name).aexists():
+            raise CommandError(f"Agent '{name}' already exists")
+        
+        # Get creator user
+        creator = await self._get_creator_user(options.get('creator'))
+        
+        # Prepare agent data
+        agent_data = {
+            'name': name,
+            'instructions': instructions,
+            'deps_type': options['deps_type'],
+            'output_type': options['output_type'],
+            'model': options['model'],
+            'category': options['category'],
+            'timeout': options['timeout'],
+            'max_retries': options['max_retries'],
+            'is_public': options['public'],
+            'enable_caching': not options['no_cache'],
+            'created_by': creator,
+            'description': options['description'],
+        }
+        
+        # Add tags if provided
+        if options['tags']:
+            agent_data['tags'] = options['tags']
+        
+        # Create agent definition
+        try:
+            agent_def = await AgentDefinition.objects.acreate(**agent_data)
+            
+            self.stdout.write(
+                self.style.SUCCESS(f"✅ Created agent definition: {agent_def.name}")
+            )
+            
+            # Show agent details
+            self.stdout.write("\nAgent Details:")
+            self.stdout.write(f"  Name: {agent_def.name}")
+            self.stdout.write(f"  Display Name: {agent_def.display_name}")
+            self.stdout.write(f"  Category: {agent_def.category or 'None'}")
+            self.stdout.write(f"  Model: {agent_def.model}")
+            self.stdout.write(f"  Dependencies: {agent_def.deps_type}")
+            self.stdout.write(f"  Output Type: {agent_def.output_type}")
+            self.stdout.write(f"  Timeout: {agent_def.timeout}s")
+            self.stdout.write(f"  Max Retries: {agent_def.max_retries}")
+            self.stdout.write(f"  Public: {agent_def.is_public}")
+            self.stdout.write(f"  Caching: {agent_def.enable_caching}")
+            self.stdout.write(f"  Created by: {agent_def.created_by.username}")
+            
+            if agent_def.tags:
+                self.stdout.write(f"  Tags: {', '.join(agent_def.tags)}")
+            
+            if agent_def.description:
+                self.stdout.write(f"  Description: {agent_def.description}")
+            
+            # Instructions preview
+            instructions_preview = agent_def.instructions[:200]
+            if len(agent_def.instructions) > 200:
+                instructions_preview += "..."
+            
+            self.stdout.write(f"  Instructions: {instructions_preview}")
+            
+        except Exception as e:
+            raise CommandError(f"Failed to create agent: {e}")
+    
+    async def _get_creator_user(self, username):
+        """Get creator user."""
+        if username:
+            try:
+                return await User.objects.aget(username=username)
+            except User.DoesNotExist:
+                raise CommandError(f"User '{username}' not found")
+        else:
+            # Use first superuser
+            try:
+                return await User.objects.filter(is_superuser=True).afirst()
+            except User.DoesNotExist:
+                raise CommandError("No superuser found. Please create a superuser first or specify --creator")
+
+
+class Command(BaseCommand):
+    """Load agent definitions from templates."""
+    
+    help = 'Load pre-built agent templates'
+    
+    def add_arguments(self, parser):
+        """Add command arguments."""
+        parser.add_argument(
+            '--list',
+            action='store_true',
+            help='List available templates'
+        )
+        parser.add_argument(
+            '--load',
+            type=str,
+            nargs='*',
+            help='Load specific templates (space-separated names)'
+        )
+        parser.add_argument(
+            '--load-all',
+            action='store_true',
+            help='Load all available templates'
+        )
+        parser.add_argument(
+            '--creator',
+            type=str,
+            help='Username of agent creator (defaults to first superuser)'
+        )
+    
+    def handle(self, *args, **options):
+        """Handle command execution."""
+        if options['list']:
+            self._list_templates()
+        elif options['load'] or options['load_all']:
+            asyncio.run(self._load_templates(options))
+        else:
+            self.stdout.write(
+                self.style.ERROR('Please specify --list, --load, or --load-all')
+            )
+    
+    def _list_templates(self):
+        """List available templates."""
+        templates = self._get_available_templates()
+        
+        self.stdout.write(self.style.SUCCESS('📋 Available Agent Templates:'))
+        self.stdout.write('=' * 40)
+        
+        for category, agents in templates.items():
+            self.stdout.write(f"\n{category.upper()}:")
+            for agent_name, agent_info in agents.items():
+                self.stdout.write(f"  • {agent_name}: {agent_info['description']}")
+    
+    async def _load_templates(self, options):
+        """Load templates."""
+        creator = await self._get_creator_user(options.get('creator'))
+        templates = self._get_available_templates()
+        
+        if options['load_all']:
+            # Load all templates
+            to_load = []
+            for category_templates in templates.values():
+                to_load.extend(category_templates.keys())
+        else:
+            to_load = options['load']
+        
+        loaded_count = 0
+        
+        for template_name in to_load:
+            # Find template
+            template_info = None
+            for category_templates in templates.values():
+                if template_name in category_templates:
+                    template_info = category_templates[template_name]
+                    break
+            
+            if not template_info:
+                self.stdout.write(
+                    self.style.WARNING(f"Template '{template_name}' not found")
+                )
+                continue
+            
+            # Check if agent already exists
+            if await AgentDefinition.objects.filter(name=template_name).aexists():
+                self.stdout.write(
+                    self.style.WARNING(f"Agent '{template_name}' already exists, skipping")
+                )
+                continue
+            
+            # Create agent
+            try:
+                agent_data = template_info.copy()
+                agent_data['name'] = template_name
+                agent_data['created_by'] = creator
+                
+                await AgentDefinition.objects.acreate(**agent_data)
+                
+                self.stdout.write(
+                    self.style.SUCCESS(f"✅ Loaded template: {template_name}")
+                )
+                loaded_count += 1
+                
+            except Exception as e:
+                self.stdout.write(
+                    self.style.ERROR(f"Failed to load template '{template_name}': {e}")
+                )
+        
+        self.stdout.write(
+            self.style.SUCCESS(f"\n🎉 Loaded {loaded_count} agent templates")
+        )
+    
+    def _get_available_templates(self):
+        """Get available agent templates."""
+        return {
+            'content': {
+                'content_analyzer': {
+                    'description': 'Analyze content sentiment, topics, and quality',
+                    'instructions': 'Analyze content for sentiment, topics, keywords, and quality metrics.',
+                    'deps_type': 'ContentDeps',
+                    'output_type': 'AnalysisResult',
+                    'category': 'content',
+                    'model': 'openai:gpt-4o-mini',
+                },
+                'content_generator': {
+                    'description': 'Generate high-quality content based on requirements',
+                    'instructions': 'Generate engaging, well-structured content based on type, audience, and style requirements.',
+                    'deps_type': 'ContentDeps',
+                    'output_type': 'ProcessResult',
+                    'category': 'content',
+                    'model': 'openai:gpt-4o-mini',
+                },
+                'content_validator': {
+                    'description': 'Validate content quality and compliance',
+                    'instructions': 'Validate content for grammar, style, accuracy, and guideline compliance.',
+                    'deps_type': 'ContentDeps',
+                    'output_type': 'ValidationResult',
+                    'category': 'content',
+                    'model': 'openai:gpt-4o-mini',
+                },
+            },
+            'data': {
+                'data_processor': {
+                    'description': 'Process and transform data',
+                    'instructions': 'Process, clean, and transform data according to specifications.',
+                    'deps_type': 'DataProcessingDeps',
+                    'output_type': 'ProcessResult',
+                    'category': 'data',
+                    'model': 'openai:gpt-4o-mini',
+                },
+                'data_validator': {
+                    'description': 'Validate data quality and integrity',
+                    'instructions': 'Validate data quality, check for errors, and ensure integrity.',
+                    'deps_type': 'DataProcessingDeps',
+                    'output_type': 'ValidationResult',
+                    'category': 'data',
+                    'model': 'openai:gpt-4o-mini',
+                },
+            },
+            'business': {
+                'business_rules': {
+                    'description': 'Apply business rules and logic',
+                    'instructions': 'Apply business rules, validate decisions, and ensure compliance.',
+                    'deps_type': 'BusinessLogicDeps',
+                    'output_type': 'ProcessResult',
+                    'category': 'business',
+                    'model': 'openai:gpt-4o-mini',
+                },
+                'decision_maker': {
+                    'description': 'Make decisions based on criteria',
+                    'instructions': 'Analyze options and make informed decisions based on criteria and context.',
+                    'deps_type': 'BusinessLogicDeps',
+                    'output_type': 'ProcessResult',
+                    'category': 'business',
+                    'model': 'openai:gpt-4o-mini',
+                },
+            }
+        }
+    
+    async def _get_creator_user(self, username):
+        """Get creator user."""
+        if username:
+            try:
+                return await User.objects.aget(username=username)
+            except User.DoesNotExist:
+                raise CommandError(f"User '{username}' not found")
+        else:
+            # Use first superuser
+            try:
+                return await User.objects.filter(is_superuser=True).afirst()
+            except User.DoesNotExist:
+                raise CommandError("No superuser found. Please create a superuser first or specify --creator")

django_cfg/apps/agents/management/commands/orchestrator_status.py

@@ -0,0 +1,191 @@
+"""
+Management command to show orchestrator status.
+"""
+
+import asyncio
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+from datetime import timedelta
+
+from django_cfg.modules.django_orchestrator.integration.registry import get_registry
+from django_cfg.modules.django_orchestrator.models.execution import AgentExecution, WorkflowExecution
+from django_cfg.modules.django_orchestrator.models.registry import AgentDefinition
+
+
+class Command(BaseCommand):
+    """Show Django Orchestrator status and statistics."""
+    
+    help = 'Display Django Orchestrator status and statistics'
+    
+    def add_arguments(self, parser):
+        """Add command arguments."""
+        parser.add_argument(
+            '--detailed',
+            action='store_true',
+            help='Show detailed statistics'
+        )
+        parser.add_argument(
+            '--agents',
+            action='store_true',
+            help='Show agent-specific statistics'
+        )
+        parser.add_argument(
+            '--recent',
+            type=int,
+            default=24,
+            help='Show statistics for recent hours (default: 24)'
+        )
+    
+    def handle(self, *args, **options):
+        """Handle command execution."""
+        self.stdout.write(
+            self.style.SUCCESS('🤖 Django Orchestrator Status')
+        )
+        self.stdout.write('=' * 50)
+        
+        # Run async operations
+        asyncio.run(self._show_status(options))
+    
+    async def _show_status(self, options):
+        """Show orchestrator status."""
+        # Registry status
+        await self._show_registry_status()
+        
+        # Database statistics
+        await self._show_database_stats(options['recent'])
+        
+        if options['detailed']:
+            await self._show_detailed_stats(options['recent'])
+        
+        if options['agents']:
+            await self._show_agent_stats(options['recent'])
+    
+    async def _show_registry_status(self):
+        """Show registry status."""
+        self.stdout.write('\n📋 Registry Status:')
+        
+        registry = get_registry()
+        metrics = registry.get_agent_metrics()
+        
+        self.stdout.write(f"  Runtime Agents: {metrics['runtime_agents_count']}")
+        self.stdout.write(f"  Available Patterns: {len(metrics['orchestrator_metrics']['available_patterns'])}")
+        
+        if metrics['agent_names']:
+            self.stdout.write(f"  Loaded Agents: {', '.join(metrics['agent_names'])}")
+        else:
+            self.stdout.write("  No agents currently loaded")
+    
+    async def _show_database_stats(self, recent_hours):
+        """Show database statistics."""
+        self.stdout.write('\n📊 Database Statistics:')
+        
+        # Total counts
+        total_definitions = await AgentDefinition.objects.acount()
+        active_definitions = await AgentDefinition.objects.filter(is_active=True).acount()
+        
+        self.stdout.write(f"  Agent Definitions: {total_definitions} ({active_definitions} active)")
+        
+        # Recent activity
+        since = timezone.now() - timedelta(hours=recent_hours)
+        
+        recent_executions = await AgentExecution.objects.filter(created_at__gte=since).acount()
+        recent_workflows = await WorkflowExecution.objects.filter(created_at__gte=since).acount()
+        
+        self.stdout.write(f"  Recent Executions ({recent_hours}h): {recent_executions} agents, {recent_workflows} workflows")
+        
+        # Success rates
+        total_executions = await AgentExecution.objects.acount()
+        successful_executions = await AgentExecution.objects.filter(status='completed').acount()
+        
+        if total_executions > 0:
+            success_rate = (successful_executions / total_executions) * 100
+            self.stdout.write(f"  Overall Success Rate: {success_rate:.1f}%")
+    
+    async def _show_detailed_stats(self, recent_hours):
+        """Show detailed statistics."""
+        self.stdout.write('\n📈 Detailed Statistics:')
+        
+        since = timezone.now() - timedelta(hours=recent_hours)
+        
+        # Execution status breakdown
+        statuses = {}
+        async for execution in AgentExecution.objects.filter(created_at__gte=since):
+            statuses[execution.status] = statuses.get(execution.status, 0) + 1
+        
+        if statuses:
+            self.stdout.write(f"  Execution Status (last {recent_hours}h):")
+            for status, count in statuses.items():
+                self.stdout.write(f"    {status.title()}: {count}")
+        
+        # Average execution time
+        from django.db.models import Avg
+        avg_time = await AgentExecution.objects.filter(
+            created_at__gte=since,
+            execution_time__isnull=False
+        ).aaggregate(avg_time=Avg('execution_time'))
+        
+        if avg_time['avg_time']:
+            self.stdout.write(f"  Average Execution Time: {avg_time['avg_time']:.2f}s")
+        
+        # Token usage
+        from django.db.models import Sum
+        token_stats = await AgentExecution.objects.filter(
+            created_at__gte=since
+        ).aaggregate(
+            total_tokens=Sum('tokens_used'),
+            total_cost=Sum('cost')
+        )
+        
+        if token_stats['total_tokens']:
+            self.stdout.write(f"  Total Tokens Used: {token_stats['total_tokens']:,}")
+        
+        if token_stats['total_cost']:
+            self.stdout.write(f"  Total Cost: ${token_stats['total_cost']:.4f}")
+    
+    async def _show_agent_stats(self, recent_hours):
+        """Show agent-specific statistics."""
+        self.stdout.write('\n🤖 Agent Statistics:')
+        
+        since = timezone.now() - timedelta(hours=recent_hours)
+        
+        # Most used agents
+        from django.db.models import Count
+        agent_usage = []
+        
+        async for item in AgentExecution.objects.filter(
+            created_at__gte=since
+        ).values('agent_name').annotate(
+            count=Count('id')
+        ).order_by('-count')[:10]:
+            agent_usage.append((item['agent_name'], item['count']))
+        
+        if agent_usage:
+            self.stdout.write(f"  Most Used Agents (last {recent_hours}h):")
+            for agent_name, count in agent_usage:
+                self.stdout.write(f"    {agent_name}: {count} executions")
+        
+        # Agent definitions by category
+        categories = {}
+        async for agent_def in AgentDefinition.objects.filter(is_active=True):
+            category = agent_def.category or 'uncategorized'
+            categories[category] = categories.get(category, 0) + 1
+        
+        if categories:
+            self.stdout.write("  Agents by Category:")
+            for category, count in sorted(categories.items()):
+                self.stdout.write(f"    {category.title()}: {count}")
+        
+        # Registry runtime status
+        registry = get_registry()
+        runtime_agents = registry.get_runtime_agents()
+        
+        if runtime_agents:
+            self.stdout.write("  Runtime Agent Metrics:")
+            for agent_name, agent in runtime_agents.items():
+                metrics = agent.get_metrics()
+                self.stdout.write(
+                    f"    {agent_name}: "
+                    f"{metrics['execution_count']} runs, "
+                    f"{metrics['success_rate']:.1%} success, "
+                    f"{metrics['cache_hit_rate']:.1%} cache hit"
+                )

django_cfg/apps/agents/managers/__init__.py

@@ -0,0 +1,23 @@
+"""
+Django Agents - Custom model managers.
+"""
+
+from .execution import AgentExecutionManager, WorkflowExecutionManager
+from .registry import AgentDefinitionManager, AgentTemplateManager
+from .toolsets import ToolExecutionManager, ApprovalLogManager, ToolsetConfigurationManager, ToolPermissionManager
+
+__all__ = [
+    # Execution managers
+    'AgentExecutionManager',
+    'WorkflowExecutionManager',
+    
+    # Registry managers
+    'AgentDefinitionManager',
+    'AgentTemplateManager',
+    
+    # Toolsets managers
+    'ToolExecutionManager',
+    'ApprovalLogManager',
+    'ToolsetConfigurationManager',
+    'ToolPermissionManager',
+]