Assign AI Agents to Automate Workflows

import asyncio
from praisonai_platform.client import PlatformClient

async def create_code_review_agent():
    client = PlatformClient("http://localhost:8000", token="your-jwt-token")
    ws_id = "your-workspace-id"
    
    agent = await client.create_agent(
        ws_id,
        name="Senior Code Reviewer",
        description="AI agent specialized in code review and quality analysis",
        instructions="""
        You are a senior software engineer with expertise in code review.
        
        When assigned to an issue:
        1. Analyze any code snippets or repository links provided
        2. Check for common issues: security vulnerabilities, performance problems, code smells
        3. Review for best practices: SOLID principles, clean code, proper error handling
        4. Suggest specific improvements with code examples
        5. Rate severity: critical, high, medium, low
        6. Add your review as a structured comment
        
        Format your response as:
        ## Code Review Analysis
        **Severity**: [level]
        **Issues Found**: [number]
        
        ### Critical Issues
        - [specific issue with line numbers if available]
        
        ### Suggestions
        - [actionable recommendations]
        
        ### Code Examples
        # [language] example
        # Improved version of the suggested code
        """,
        model="gpt-4o",
        auto_assign_labels=["code-reviewed", "ai-analyzed"],
        triggers={
            "on_assign": True,
            "on_label_added": ["needs-review", "pull-request"],
            "on_comment_keywords": ["@code-review", "review please"]
        }
    )
    
    print(f"✅ Created code review agent: {agent['name']}")
    return agent

code_agent = asyncio.run(create_code_review_agent())

async def assign_code_review():
    client = PlatformClient("http://localhost:8000", token="your-jwt-token")
    ws_id = "your-workspace-id"
    
    # Create a code-related issue
    code_issue = await client.create_issue(
        ws_id,
        title="Refactor authentication middleware",
        description="""
        Current authentication middleware has performance issues and security concerns.
        
        Current implementation (simplified):
        # def auth_middleware(request):
        #     token = request.headers.get("Authorization")
        #     if token:
        #         user = decode_token(token)
        #         if user and user.is_active:
        #             request.user = user
        #             return True
        #     return False
        
        Issues:
        - Database call on every request
        - No token caching
        - Missing rate limiting
        - No proper error handling
        """,
        labels=["backend", "security", "performance", "needs-review"],
        priority="high"
    )
    
    # Assign the code review agent
    await client.assign_issue_agent(ws_id, code_issue['id'], code_agent['id'])
    
    print(f"✅ Assigned code review agent to issue {code_issue['identifier']}")
    return code_issue

issue = asyncio.run(assign_code_review())

async def create_bug_triage_agent():
    client = PlatformClient("http://localhost:8000", token="your-jwt-token")
    ws_id = "your-workspace-id"
    
    agent = await client.create_agent(
        ws_id,
        name="Bug Triage Specialist",
        description="Analyzes bug reports and categorizes them for efficient resolution",
        instructions="""
        You are a QA specialist that triages incoming bug reports.
        
        For each bug report:
        1. Analyze severity based on impact and frequency
        2. Identify the likely component/system affected
        3. Suggest reproduction steps if missing
        4. Recommend initial debugging approach
        5. Assign appropriate priority and labels
        6. Determine if immediate escalation is needed
        
        Severity levels:
        - Critical: System down, security breach, data loss
        - High: Core functionality broken, many users affected
        - Medium: Feature not working, some users affected  
        - Low: Minor issue, cosmetic problems
        
        Always add these labels based on analysis:
        - Component: frontend, backend, database, api
        - Priority: critical, high, medium, low
        - Type: crash, performance, ui-bug, data-issue
        """,
        model="gpt-4o-mini",  # Faster model for triage
        auto_assign_labels=["triaged", "ai-categorized"],
        triggers={
            "on_assign": True,
            "on_label_added": ["bug", "issue"],
            "on_status_change": "reported"
        }
    )
    
    print(f"✅ Created bug triage agent: {agent['name']}")
    return agent

triage_agent = asyncio.run(create_bug_triage_agent())

async def setup_auto_bug_triage():
    client = PlatformClient("http://localhost:8000", token="your-jwt-token")
    ws_id = "your-workspace-id"
    
    # Set up automatic assignment rule
    automation_rule = await client.create_automation_rule(
        ws_id,
        name="Auto Bug Triage",
        description="Automatically assign triage agent to new bug reports",
        triggers=[
            {
                "type": "issue_created",
                "conditions": {
                    "labels_include": ["bug"],
                    "status": "reported"
                }
            }
        ],
        actions=[
            {
                "type": "assign_agent",
                "agent_id": triage_agent['id']
            },
            {
                "type": "add_comment",
                "content": "🤖 Bug triage agent assigned. Analysis in progress..."
            }
        ]
    )
    
    # Test with a sample bug report
    bug_report = await client.create_issue(
        ws_id,
        title="App crashes when uploading large files",
        description="""
        **Steps to reproduce:**
        1. Go to file upload page
        2. Select file larger than 10MB
        3. Click upload button
        
        **Expected:** File uploads successfully
        **Actual:** App crashes with white screen
        
        **Additional info:**
        - Happens on both Chrome and Firefox
        - Only with files >10MB
        - Started after last update
        - Error in console: "Memory limit exceeded"
        """,
        labels=["bug"],
        status="reported"
    )
    
    print(f"✅ Created bug report {bug_report['identifier']} - agent will auto-assign")
    return automation_rule, bug_report

rule, bug = asyncio.run(setup_auto_bug_triage())

async def create_docs_agent():
    client = PlatformClient("http://localhost:8000", token="your-jwt-token")
    ws_id = "your-workspace-id"
    
    agent = await client.create_agent(
        ws_id,
        name="Documentation Writer",
        description="Generates and updates technical documentation",
        instructions="""
        You are a technical writer that creates clear, comprehensive documentation.
        
        When assigned to documentation tasks:
        1. Analyze the feature/API that needs documentation
        2. Create structured documentation with:
           - Clear overview and purpose
           - Step-by-step usage instructions
           - Code examples with proper formatting
           - Common use cases and patterns
           - Troubleshooting section
           - Links to related resources
        
        Follow these standards:
        - Use Markdown formatting
        - Include runnable code examples
        - Add appropriate headers and structure
        - Use clear, jargon-free language
        - Include both basic and advanced usage
        
        For API documentation, always include:
        - Request/response examples
        - Parameter descriptions
        - Error codes and handling
        - Rate limiting information
        """,
        model="gpt-4o",
        auto_assign_labels=["documented", "ready-for-review"],
        file_access=True,  # Allow reading/writing documentation files
        triggers={
            "on_assign": True,
            "on_label_added": ["needs-docs", "api-change"]
        }
    )
    
    return agent

docs_agent = asyncio.run(create_docs_agent())

async def generate_api_docs():
    client = PlatformClient("http://localhost:8000", token="your-jwt-token")
    ws_id = "your-workspace-id"
    
    # Create documentation request
    docs_issue = await client.create_issue(
        ws_id,
        title="Document new webhook API endpoints",
        description="""
        New webhook API endpoints need comprehensive documentation:
        
        **New Endpoints:**
        - POST /api/v1/webhooks - Create webhook
        - GET /api/v1/webhooks - List webhooks  
        - PUT /api/v1/webhooks/{id} - Update webhook
        - DELETE /api/v1/webhooks/{id} - Delete webhook
        
        **Requirements:**
        - Include request/response schemas
        - Add authentication examples
        - Document webhook event types
        - Provide testing instructions
        - Add troubleshooting guide
        
        **Target Audience:** External developers integrating with our API
        """,
        labels=["documentation", "api", "needs-docs"],
        priority="medium",
        assignee_type="agent",
        assignee_id=docs_agent['id']
    )
    
    print(f"✅ Documentation request created: {docs_issue['identifier']}")
    
    # Add additional context for the agent
    await client.add_issue_comment(
        ws_id,
        docs_issue['id'],
        """
        Additional context for documentation:
        
        **Webhook Event Types:**
        - issue.created, issue.updated, issue.deleted
        - project.created, project.updated
        - agent.assigned, agent.completed
        
        **Authentication:** Bearer token required
        **Rate Limits:** 100 requests/hour per webhook
        **Payload Size:** Maximum 1MB per webhook call
        """
    )
    
    return docs_issue

docs_task = asyncio.run(generate_api_docs())