1. Otvoriť Jira
2. Filtrovať tasky podľa priority
3. Vybrať task
4. Prečítať requirements
5. Zmeniť status na "In Progress"
6. Otvoriť terminal
7. Vytvoriť branch manuálne:
   git checkout main
   git pull
   git checkout -b feature/PROJ-123-user-authentication
8. Otvoriť IDE
9. Začať vývoj
10. Napísať kód
11. Napísať testy
12. Spustiť testy
13. Vytvoriť PR manuálne
14. Napísať PR description
15. Vrátiť sa do Jiry
16. Updatovať ticket
17. Zapísať hodiny do time-tracking systému
18. Zapísať hodiny do firemného ERP
19. ...

Čas: ~30-45 minút len na setup

You: "Claude, zober ticket s najvyššou prioritou a začni na ňom pracovať."

Claude (cez MCP):
[MCP Jira] Získavam tickets...
[MCP Jira] Top priority: PROJ-123 "Implementovať user authentication"
[MCP Jira] Status zmenený: "To Do" → "In Progress"
[MCP GitHub] Vytváram branch: feature/proj-123-user-authentication
[MCP GitHub] Branch vytvorený z main

"Pripravil som ti task PROJ-123. Ide o implementáciu user authentication.
Požiadavky:
- JWT token-based auth
- bcrypt password hashing
- Email verification
- Rate limiting

Vytvoril som branch: feature/proj-123-user-authentication

Chceš, aby som ti najprv vytvoril development plan?"

You: "Áno, vytvor plan a napíš testovacie scenáre pre QA."

Claude:
[Analyzuje requirements]
[MCP Jira] Pridávam komentár s testovacími scenármi...

"Vytvoril som development plan a pridal testovacie scenáre do Jiry..."

Čas: ~5 minút setup, zvyšok je produktívny vývoj

# development-workflow-server.py
from mcp.server import Server
from mcp.types import Tool, Resource
import jira
import github
import subprocess

server = Server("dev-workflow")

# === JIRA TOOLS ===

@server.tool()
async def get_highest_priority_ticket(project: str) -> dict:
    """
    Získa ticket s najvyššou prioritou z projektu.

    Args:
        project: Kľúč projektu (napr. "PROJ")

    Returns:
        Jira ticket s najvyššou prioritou
    """
    tickets = jira_client.search_issues(
        f'project={project} AND status="To Do" ORDER BY priority DESC',
        maxResults=1
    )
    return tickets[0].raw if tickets else None

@server.tool()
async def update_ticket_status(ticket_id: str, status: str) -> dict:
    """
    Zmení status Jira ticketu.

    Args:
        ticket_id: ID ticketu (napr. "PROJ-123")
        status: Nový status ("In Progress", "Code Review", "Done")
    """
    jira_client.transition_issue(ticket_id, status)
    return {"success": True, "ticket": ticket_id, "new_status": status}

@server.tool()
async def add_test_scenarios_to_ticket(ticket_id: str, scenarios: list[str]) -> dict:
    """
    Pridá testovacie scenáre do Jira ticketu ako komentár.

    Args:
        ticket_id: ID ticketu
        scenarios: List testovacích scenárov
    """
    comment = "**Testovacie scenáre:**\n\n"
    comment += "\n".join(f"- {s}" for s in scenarios)

    jira_client.add_comment(ticket_id, comment)
    return {"success": True, "scenarios_count": len(scenarios)}

# === GITHUB TOOLS ===

@server.tool()
async def create_branch_from_ticket(
    ticket_id: str,
    ticket_summary: str,
    base_branch: str = "main",
    branch_type: str = "feature"
) -> dict:
    """
    Vytvorí git branch podľa pattern: {type}/{ticket_id}-{slug}

    Args:
        ticket_id: ID ticketu (napr. "PROJ-123")
        ticket_summary: Summary ticketu
        base_branch: Base branch (default: "main")
        branch_type: Typ branchu ("feature", "bugfix", "hotfix")

    Returns:
        Info o vytvorenom branchi
    """
    slug = ticket_summary.lower().replace(" ", "-")[:50]
    branch_name = f"{branch_type}/{ticket_id.lower()}-{slug}"

    # Get base branch SHA
    base_ref = github_repo.get_branch(base_branch)

    # Create new branch
    github_repo.create_git_ref(
        ref=f"refs/heads/{branch_name}",
        sha=base_ref.commit.sha
    )

    # Checkout locally
    subprocess.run(["git", "fetch"])
    subprocess.run(["git", "checkout", branch_name])

    return {
        "branch_name": branch_name,
        "base_branch": base_branch,
        "url": f"https://github.com/{github_repo.full_name}/tree/{branch_name}"
    }

@server.tool()
async def create_pull_request(
    branch_name: str,
    title: str,
    description: str,
    base_branch: str = "main"
) -> dict:
    """
    Vytvorí Pull Request.

    Args:
        branch_name: Názov source branchu
        title: Názov PR
        description: Popis PR
        base_branch: Target branch (default: "main")
    """
    pr = github_repo.create_pull(
        title=title,
        body=description,
        head=branch_name,
        base=base_branch
    )

    return {
        "pr_number": pr.number,
        "url": pr.html_url,
        "title": title
    }

# === COMPOSITE WORKFLOWS ===

@server.tool()
async def start_work_on_ticket(project: str) -> dict:
    """
    Komplexný workflow:
    1. Získa ticket s najvyššou prioritou
    2. Zmení status na "In Progress"
    3. Vytvorí branch

    Args:
        project: Kľúč projektu
    """
    # 1. Get ticket
    ticket = await get_highest_priority_ticket(project)
    if not ticket:
        return {"error": "No tickets found"}

    ticket_id = ticket['key']
    summary = ticket['fields']['summary']

    # 2. Update status
    await update_ticket_status(ticket_id, "In Progress")

    # 3. Create branch
    branch_type = "feature" if "feature" in summary.lower() else "bugfix"
    branch_info = await create_branch_from_ticket(
        ticket_id,
        summary,
        branch_type=branch_type
    )

    return {
        "ticket": {
            "id": ticket_id,
            "summary": summary,
            "description": ticket['fields']['description']
        },
        "branch": branch_info,
        "status": "Ready to code!"
    }

if __name__ == "__main__":
    server.run()

# Install dependencies
pip install mcp jira pygithub

# Run server
python development-workflow-server.py

{
  "mcpServers": {
    "dev-workflow": {
      "command": "python",
      "args": ["/path/to/development-workflow-server.py"],
      "env": {
        "JIRA_URL": "https://company.atlassian.net",
        "JIRA_EMAIL": "your-email@company.com",
        "JIRA_API_TOKEN": "your-jira-token",
        "GITHUB_TOKEN": "your-github-token",
        "GITHUB_REPO": "company/repository"
      }
    }
  }
}

You: "Deploy latest version do staging"

Claude:
[MCP Docker] Building image...
[MCP Docker] Image built: app:v1.2.3
[MCP Kubernetes] Applying deployment...
[MCP Kubernetes] Pods starting...
[MCP Slack] Notifying #deployments channel...
[MCP Jira] Updating release notes...

"Deployment dokončený:
- Image: app:v1.2.3
- Pods: 3/3 running
- Health check: ✓ passing
- Notifikácia odoslaná do Slacku
- Release notes updatované v Jire"

You: "Analyzuj sales data z Q4 a vytvor report"

Claude:
[MCP PostgreSQL] Querying sales data...
[MCP PostgreSQL] 15,234 records retrieved
[Analyzuje data]
[MCP Google Drive] Creating report document...
[MCP Slack] Sharing with #sales team...

"Vytvoril som Q4 sales report:
- Total revenue: $1.2M (+15% vs Q3)
- Top product: Premium Plan (45% revenue)
- Report: https://drive.google.com/...
- Zdieľané v Slacku"

You: "Zisti, prečo customer XYZ má problém s platenosťou"

Claude:
[MCP PostgreSQL] Checking customer records...
[MCP Stripe] Checking payment history...
[MCP Gmail] Searching support emails...
[MCP Jira] Checking open tickets...

"Našiel som problém:
- Customer: XYZ Corp
- Issue: Credit card expired 3 days ago
- Open ticket: SUP-789 (created yesterday)
- Last payment attempt: Failed (expired card)
- Previous tickets: 2 (resolved)

Chceš, aby som poslal reminder email o update platobných údajov?"

# ❌ ZLÉ
jira_token = "your-token-here"

# ✅ DOBRÉ
import os
jira_token = os.getenv("JIRA_API_TOKEN")

from functools import wraps
import time

def rate_limit(calls_per_minute=60):
    def decorator(func):
        last_called = [0.0]

        @wraps(func)
        async def wrapper(*args, **kwargs):
            elapsed = time.time() - last_called[0]
            if elapsed < 60 / calls_per_minute:
                await asyncio.sleep((60 / calls_per_minute) - elapsed)

            last_called[0] = time.time()
            return await func(*args, **kwargs)

        return wrapper
    return decorator

@server.tool()
@rate_limit(calls_per_minute=30)
async def expensive_api_call():
    # ...

from pydantic import BaseModel, validator

class TicketUpdate(BaseModel):
    ticket_id: str
    status: str

    @validator('ticket_id')
    def validate_ticket_id(cls, v):
        if not v.match(r'^[A-Z]+-\d+$'):
            raise ValueError('Invalid ticket ID format')
        return v

    @validator('status')
    def validate_status(cls, v):
        allowed = ['To Do', 'In Progress', 'Code Review', 'Done']
        if v not in allowed:
            raise ValueError(f'Status must be one of: {allowed}')
        return v

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@server.tool()
async def critical_operation(data: dict):
    logger.info(f"Starting critical operation: {data}")

    try:
        result = await perform_operation(data)
        logger.info(f"Operation successful: {result}")
        return result
    except Exception as e:
        logger.error(f"Operation failed: {e}")
        raise