📦 Step 1: 환경 설정 및 설치

먼저 OpenDevin을 설치하고 기본 환경을 구축해야 해. 생각보다 간단하니까 걱정 마!

필요한 것들:

• Python 3.10 이상
• Docker (OpenDevin은 샌드박스 환경에서 실행돼)
• Git
• 충분한 메모리 (최소 8GB RAM 권장)

설치 과정:

# OpenDevin 저장소 클론
git clone https://github.com/OpenDevin/OpenDevin.git
cd OpenDevin

# 가상환경 생성 및 활성화
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

# 필요한 패키지 설치
pip install -r requirements.txt

# Docker 이미지 빌드
docker build -t opendevin .

# 환경 변수 설정
cp .env.example .env
# .env 파일을 열어서 API 키 등을 설정해줘

🎨 Step 2: 버그 리포트 데이터 구조 설계

시스템이 효율적으로 작동하려면 버그 리포트를 어떻게 구조화할지 먼저 정해야 해. 표준화된 형식이 있어야 AI가 제대로 이해하고 처리할 수 있거든.

추천하는 버그 리포트 구조:

{
  "id": "BUG-2024-001",
  "title": "로그인 버튼 클릭 시 응답 없음",
  "description": "사용자가 로그인 버튼을 클릭해도 아무 반응이 없습니다.",
  "reporter": "user@example.com",
  "reported_date": "2024-01-15T10:30:00Z",
  "status": "open",
  "priority": null,  // AI가 자동으로 설정
  "category": null,  // AI가 자동으로 분류
  "tags": [],  // AI가 자동으로 생성
  "duplicate_of": null,  // 중복 버그 ID
  "environment": {
    "os": "Windows 11",
    "browser": "Chrome 120",
    "version": "1.5.2"
  },
  "steps_to_reproduce": [
    "1. 로그인 페이지 접속",
    "2. 이메일과 비밀번호 입력",
    "3. 로그인 버튼 클릭"
  ],
  "expected_result": "로그인 성공 후 대시보드로 이동",
  "actual_result": "버튼 클릭 후 아무 반응 없음",
  "attachments": [],
  "assigned_to": null,  // AI가 추천
  "ai_analysis": null  // AI 분석 결과
}

이런 구조를 기본으로 하되, 프로젝트 특성에 맞게 필드를 추가하거나 수정할 수 있어. 중요한 건 일관성이야! 🎯

🤖 Step 3: OpenDevin 에이전트 설정

이제 OpenDevin 에이전트를 버그 리포트 정리에 특화되도록 설정해볼 거야. 에이전트에게 명확한 역할과 지침을 주는 게 중요해!

에이전트 설정 파일 (agent_config.yaml):

agent:
  name: "BugReportOrganizer"
  role: "버그 리포트 자동 정리 전문가"
  
  capabilities:
    - analyze_bug_reports
    - categorize_issues
    - detect_duplicates
    - assign_priority
    - generate_tags
    - recommend_assignee
    
  instructions: |
    당신은 버그 리포트를 분석하고 정리하는 AI 에이전트입니다.
    다음 작업을 수행하세요:
    
    1. 버그 리포트의 내용을 분석하여 핵심 문제를 파악
    2. 적절한 카테고리로 분류 (UI, Backend, Database, Performance 등)
    3. 심각도와 영향 범위를 고려하여 우선순위 설정
    4. 기존 리포트와 비교하여 중복 여부 확인
    5. 관련 키워드를 추출하여 태그 생성
    6. 버그 유형과 팀 구성을 고려하여 적절한 담당자 추천
    
  context:
    project_type: "web_application"
    team_structure:
      - name: "Frontend Team"
        skills: ["React", "CSS", "JavaScript"]
      - name: "Backend Team"
        skills: ["Python", "Django", "PostgreSQL"]
      - name: "DevOps Team"
        skills: ["Docker", "AWS", "CI/CD"]
        
  rules:
    - "중복 버그는 반드시 원본 버그 ID를 참조할 것"
    - "우선순위는 Critical, High, Medium, Low 4단계로 구분"
    - "카테고리는 프로젝트 구조에 맞게 일관성 있게 분류"
    - "태그는 최대 5개까지만 생성"

이 설정 파일은 에이전트가 어떻게 행동해야 하는지 알려주는 일종의 매뉴얼이야. 프로젝트마다 다르게 커스터마이징할 수 있어! 📝

💻 Step 4: 자동화 스크립트 작성

이제 실제로 버그 리포트를 처리하는 스크립트를 작성해볼 거야. Python으로 작성할 건데, 단계별로 설명해줄게!

메인 스크립트 (bug_organizer.py):

import json
import asyncio
from opendevin import Agent, Task
from datetime import datetime

class BugReportOrganizer:
    def __init__(self, config_path="agent_config.yaml"):
        """버그 리포트 정리 시스템 초기화"""
        self.agent = Agent.from_config(config_path)
        self.processed_bugs = []
        
    async def process_bug_report(self, bug_report):
        """개별 버그 리포트 처리"""
        print(f"🔍 처리 중: {bug_report['id']}")
        
        # AI 에이전트에게 분석 요청
        task = Task(
            instruction=f"""
            다음 버그 리포트를 분석하고 정리해주세요:
            
            제목: {bug_report['title']}
            설명: {bug_report['description']}
            재현 단계: {bug_report.get('steps_to_reproduce', [])}
            환경: {bug_report.get('environment', {})}
            
            다음 정보를 JSON 형식으로 제공해주세요:
            1. category: 버그 카테고리
            2. priority: 우선순위 (Critical/High/Medium/Low)
            3. tags: 관련 태그 리스트 (최대 5개)
            4. summary: 한 줄 요약
            5. recommended_assignee: 추천 담당자
            6. estimated_effort: 예상 작업 시간 (hours)
            """,
            context={"bug_report": bug_report}
        )
        
        result = await self.agent.execute(task)
        
        # 결과를 버그 리포트에 추가
        analysis = json.loads(result.output)
        bug_report.update({
            "category": analysis["category"],
            "priority": analysis["priority"],
            "tags": analysis["tags"],
            "ai_summary": analysis["summary"],
            "assigned_to": analysis["recommended_assignee"],
            "estimated_effort": analysis["estimated_effort"],
            "processed_date": datetime.now().isoformat()
        })
        
        return bug_report
    
    async def detect_duplicates(self, new_bug, existing_bugs):
        """중복 버그 탐지"""
        task = Task(
            instruction=f"""
            새로운 버그 리포트가 기존 버그들과 중복되는지 확인해주세요.
            
            새 버그:
            제목: {new_bug['title']}
            설명: {new_bug['description']}
            
            기존 버그들:
            {json.dumps([{
                'id': b['id'],
                'title': b['title'],
                'description': b['description']
            } for b in existing_bugs], ensure_ascii=False, indent=2)}
            
            중복이 있다면 해당 버그 ID를 반환하고,
            없다면 null을 반환해주세요.
            유사도가 80% 이상일 때만 중복으로 판단하세요.
            """,
            context={"new_bug": new_bug, "existing_bugs": existing_bugs}
        )
        
        result = await self.agent.execute(task)
        duplicate_id = result.output.strip()
        
        if duplicate_id and duplicate_id != "null":
            new_bug["duplicate_of"] = duplicate_id
            new_bug["status"] = "duplicate"
            print(f"✅ 중복 발견: {duplicate_id}")
        
        return new_bug
    
    async def batch_process(self, bug_reports):
        """여러 버그 리포트 일괄 처리"""
        print(f"📊 총 {len(bug_reports)}개의 버그 리포트 처리 시작...")
        
        processed = []
        for bug in bug_reports:
            # 중복 체크
            bug = await self.detect_duplicates(bug, processed)
            
            # 중복이 아닌 경우에만 상세 분석
            if bug.get("status") != "duplicate":
                bug = await self.process_bug_report(bug)
            
            processed.append(bug)
            
        self.processed_bugs = processed
        print(f"✨ 처리 완료! {len(processed)}개 버그 정리됨")
        
        return processed
    
    def generate_report(self, output_path="bug_report_summary.json"):
        """처리 결과 리포트 생성"""
        summary = {
            "total_bugs": len(self.processed_bugs),
            "by_priority": {},
            "by_category": {},
            "duplicates": 0,
            "processed_date": datetime.now().isoformat()
        }
        
        for bug in self.processed_bugs:
            # 우선순위별 집계
            priority = bug.get("priority", "Unknown")
            summary["by_priority"][priority] = \
                summary["by_priority"].get(priority, 0) + 1
            
            # 카테고리별 집계
            category = bug.get("category", "Unknown")
            summary["by_category"][category] = \
                summary["by_category"].get(category, 0) + 1
            
            # 중복 카운트
            if bug.get("status") == "duplicate":
                summary["duplicates"] += 1
        
        # 결과 저장
        with open(output_path, 'w', encoding='utf-8') as f:
            json.dump({
                "summary": summary,
                "bugs": self.processed_bugs
            }, f, ensure_ascii=False, indent=2)
        
        print(f"📄 리포트 저장됨: {output_path}")
        return summary

# 사용 예시
async def main():
    # 버그 리포트 로드 (실제로는 DB나 이슈 트래커에서 가져옴)
    bug_reports = [
        {
            "id": "BUG-001",
            "title": "로그인 버튼 클릭 시 응답 없음",
            "description": "사용자가 로그인 버튼을 클릭해도 아무 반응이 없습니다.",
            "reporter": "user1@example.com",
            "reported_date": "2024-01-15T10:30:00Z"
        },
        {
            "id": "BUG-002",
            "title": "로그인이 안 됩니다",
            "description": "로그인 화면에서 버튼을 눌러도 동작하지 않아요.",
            "reporter": "user2@example.com",
            "reported_date": "2024-01-15T11:00:00Z"
        },
        # ... 더 많은 버그 리포트
    ]
    
    # 시스템 초기화 및 실행
    organizer = BugReportOrganizer()
    processed = await organizer.batch_process(bug_reports)
    summary = organizer.generate_report()
    
    # 결과 출력
    print("\n📊 처리 결과 요약:")
    print(f"총 버그: {summary['total_bugs']}")
    print(f"중복 버그: {summary['duplicates']}")
    print(f"\n우선순위별:")
    for priority, count in summary['by_priority'].items():
        print(f"  {priority}: {count}개")
    print(f"\n카테고리별:")
    for category, count in summary['by_category'].items():
        print(f"  {category}: {count}개")

if __name__ == "__main__":
    asyncio.run(main())

이 스크립트는 버그 리포트를 받아서 AI로 분석하고, 중복을 찾고, 결과를 정리해주는 완전한 시스템이야! 🎉

🔗 Step 5: 이슈 트래커 연동

실제 프로젝트에서는 GitHub Issues, Jira, GitLab 같은 이슈 트래커를 사용하잖아? 이것들과 연동하는 방법도 알아보자!

GitHub Issues 연동 예시:

import requests
from github import Github

class GitHubIntegration:
    def __init__(self, token, repo_name):
        """GitHub 연동 초기화"""
        self.github = Github(token)
        self.repo = self.github.get_repo(repo_name)
        
    def fetch_open_issues(self):
        """열린 이슈들 가져오기"""
        issues = self.repo.get_issues(state='open')
        bug_reports = []
        
        for issue in issues:
            # 버그 라벨이 있는 이슈만 처리
            if any(label.name.lower() == 'bug' for label in issue.labels):
                bug_report = {
                    "id": f"GH-{issue.number}",
                    "title": issue.title,
                    "description": issue.body or "",
                    "reporter": issue.user.login,
                    "reported_date": issue.created_at.isoformat(),
                    "url": issue.html_url,
                    "github_issue": issue
                }
                bug_reports.append(bug_report)
        
        return bug_reports
    
    def update_issue(self, issue_number, analysis):
        """이슈에 AI 분석 결과 추가"""
        issue = self.repo.get_issue(issue_number)
        
        # 라벨 추가
        labels = [analysis['category'], analysis['priority']]
        labels.extend(analysis['tags'])
        issue.add_to_labels(*labels)
        
        # 코멘트로 분석 결과 추가
        comment = f"""
🤖 **AI 자동 분석 결과**

**카테고리**: {analysis['category']}
**우선순위**: {analysis['priority']}
**요약**: {analysis['summary']}
**예상 작업 시간**: {analysis['estimated_effort']}시간
**추천 담당자**: @{analysis['recommended_assignee']}

**태그**: {', '.join(analysis['tags'])}
        """
        issue.create_comment(comment)
        
        # 담당자 지정
        if analysis['recommended_assignee']:
            issue.add_to_assignees(analysis['recommended_assignee'])
        
        print(f"✅ GitHub 이슈 #{issue_number} 업데이트 완료")

# 사용 예시
async def github_workflow():
    # GitHub 연동
    gh = GitHubIntegration(
        token="your_github_token",
        repo_name="username/repository"
    )
    
    # 이슈 가져오기
    bug_reports = gh.fetch_open_issues()
    print(f"📥 {len(bug_reports)}개의 버그 이슈 발견")
    
    # OpenDevin으로 처리
    organizer = BugReportOrganizer()
    processed = await organizer.batch_process(bug_reports)
    
    # GitHub에 결과 반영
    for bug in processed:
        if bug.get('status') != 'duplicate':
            issue_number = int(bug['id'].split('-')[1])
            gh.update_issue(issue_number, bug)

이렇게 하면 GitHub Issues에 올라온 버그들을 자동으로 분석하고 정리할 수 있어! Jira나 다른 플랫폼도 비슷한 방식으로 연동할 수 있지. 🔗

🔮 기능 1: 예측 분석 (Predictive Analysis)

과거 버그 데이터를 학습해서 미래의 버그를 예측하는 기능이야. 정말 멋지지 않아? 😎

class PredictiveAnalyzer:
    def __init__(self, historical_data):
        """과거 버그 데이터로 초기화"""
        self.data = historical_data
        self.patterns = self._analyze_patterns()
    
    def _analyze_patterns(self):
        """버그 패턴 분석"""
        patterns = {
            "time_based": {},  # 시간대별 버그 발생 패턴
            "module_based": {},  # 모듈별 취약점
            "type_based": {}  # 버그 유형별 빈도
        }
        
        for bug in self.data:
            # 시간 패턴 (예: 배포 후 3일 이내 버그 급증)
            days_after_release = self._calculate_days_after_release(bug)
            patterns["time_based"][days_after_release] = \
                patterns["time_based"].get(days_after_release, 0) + 1
            
            # 모듈 패턴 (예: 인증 모듈에서 버그 많이 발생)
            module = bug.get("category")
            patterns["module_based"][module] = \
                patterns["module_based"].get(module, 0) + 1
            
            # 유형 패턴 (예: 메모리 누수가 자주 발생)
            bug_type = self._classify_bug_type(bug)
            patterns["type_based"][bug_type] = \
                patterns["type_based"].get(bug_type, 0) + 1
        
        return patterns
    
    async def predict_future_bugs(self, upcoming_release):
        """다음 릴리스에서 발생할 가능성 높은 버그 예측"""
        task = Task(
            instruction=f"""
            과거 버그 패턴을 분석하여 다음 릴리스에서 
            발생할 가능성이 높은 버그 유형을 예측해주세요.
            
            과거 패턴:
            {json.dumps(self.patterns, ensure_ascii=False, indent=2)}
            
            다음 릴리스 정보:
            - 변경된 모듈: {upcoming_release['changed_modules']}
            - 새로운 기능: {upcoming_release['new_features']}
            - 코드 변경량: {upcoming_release['lines_changed']}
            
            예측 결과를 다음 형식으로 제공해주세요:
            1. 예상 버그 개수
            2. 고위험 영역 (모듈/기능)
            3. 권장 테스트 전략
            4. 주의해야 할 버그 유형
            """,
            context={"patterns": self.patterns, "release": upcoming_release}
        )
        
        result = await self.agent.execute(task)
        return json.loads(result.output)
    
    def generate_risk_report(self):
        """위험도 리포트 생성"""
        high_risk_modules = sorted(
            self.patterns["module_based"].items(),
            key=lambda x: x[1],
            reverse=True
        )[:5]
        
        report = {
            "high_risk_modules": high_risk_modules,
            "peak_bug_times": self._find_peak_times(),
            "common_bug_types": self._get_common_types(),
            "recommendations": self._generate_recommendations()
        }
        
        return report

이 기능을 사용하면 릴리스 전에 어디에 집중해서 테스트해야 할지 알 수 있어. 버그를 미리 예방하는 거지! 🛡️

📊 기능 2: 실시간 대시보드

버그 현황을 한눈에 볼 수 있는 대시보드를 만들어보자. 시각화가 정말 중요하거든!

from flask import Flask, render_template, jsonify
import plotly.graph_objects as go

app = Flask(__name__)

class BugDashboard:
    def __init__(self, organizer):
        self.organizer = organizer
        
    def get_statistics(self):
        """통계 데이터 생성"""
        bugs = self.organizer.processed_bugs
        
        stats = {
            "total": len(bugs),
            "open": len([b for b in bugs if b.get("status") == "open"]),
            "in_progress": len([b for b in bugs if b.get("status") == "in_progress"]),
            "resolved": len([b for b in bugs if b.get("status") == "resolved"]),
            "duplicates": len([b for b in bugs if b.get("status") == "duplicate"]),
            
            "by_priority": {},
            "by_category": {},
            "by_assignee": {},
            
            "avg_resolution_time": self._calculate_avg_resolution_time(bugs),
            "trend": self._calculate_trend(bugs)
        }
        
        # 우선순위별 집계
        for bug in bugs:
            priority = bug.get("priority", "Unknown")
            stats["by_priority"][priority] = \
                stats["by_priority"].get(priority, 0) + 1
            
            category = bug.get("category", "Unknown")
            stats["by_category"][category] = \
                stats["by_category"].get(category, 0) + 1
            
            assignee = bug.get("assigned_to", "Unassigned")
            stats["by_assignee"][assignee] = \
                stats["by_assignee"].get(assignee, 0) + 1
        
        return stats
    
    def create_priority_chart(self):
        """우선순위별 차트 생성"""
        stats = self.get_statistics()
        priorities = list(stats["by_priority"].keys())
        counts = list(stats["by_priority"].values())
        
        fig = go.Figure(data=[
            go.Bar(
                x=priorities,
                y=counts,
                marker_color=['#dc3545', '#fd7e14', '#ffc107', '#28a745']
            )
        ])
        
        fig.update_layout(
            title="버그 우선순위 분포",
            xaxis_title="우선순위",
            yaxis_title="개수",
            template="plotly_white"
        )
        
        return fig.to_html(full_html=False)
    
    def create_category_pie_chart(self):
        """카테고리별 파이 차트"""
        stats = self.get_statistics()
        
        fig = go.Figure(data=[
            go.Pie(
                labels=list(stats["by_category"].keys()),
                values=list(stats["by_category"].values()),
                hole=0.3
            )
        ])
        
        fig.update_layout(
            title="버그 카테고리 분포",
            template="plotly_white"
        )
        
        return fig.to_html(full_html=False)
    
    def create_trend_chart(self):
        """시간별 트렌드 차트"""
        trend_data = self.get_statistics()["trend"]
        
        fig = go.Figure()
        
        fig.add_trace(go.Scatter(
            x=trend_data["dates"],
            y=trend_data["reported"],
            name="신규 버그",
            line=dict(color='#dc3545', width=2)
        ))
        
        fig.add_trace(go.Scatter(
            x=trend_data["dates"],
            y=trend_data["resolved"],
            name="해결된 버그",
            line=dict(color='#28a745', width=2)
        ))
        
        fig.update_layout(
            title="버그 트렌드",
            xaxis_title="날짜",
            yaxis_title="개수",
            template="plotly_white",
            hovermode='x unified'
        )
        
        return fig.to_html(full_html=False)

# Flask 라우트
@app.route('/')
def index():
    dashboard = BugDashboard(organizer)
    stats = dashboard.get_statistics()
    
    return render_template('dashboard.html',
        stats=stats,
        priority_chart=dashboard.create_priority_chart(),
        category_chart=dashboard.create_category_pie_chart(),
        trend_chart=dashboard.create_trend_chart()
    )

@app.route('/api/stats')
def api_stats():
    dashboard = BugDashboard(organizer)
    return jsonify(dashboard.get_statistics())

if __name__ == '__main__':
    app.run(debug=True, port=5000)

이제 브라우저에서 http://localhost:5000 으로 접속하면 멋진 대시보드를 볼 수 있어! 📈

🔔 기능 3: 스마트 알림 시스템

중요한 버그가 발생하면 자동으로 알려주는 시스템이야. Slack, Discord, 이메일 등 다양한 채널로 알림을 보낼 수 있어!

import asyncio
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError

class SmartNotificationSystem:
    def __init__(self, slack_token=None, discord_webhook=None):
        """알림 시스템 초기화"""
        self.slack_client = WebClient(token=slack_token) if slack_token else None
        self.discord_webhook = discord_webhook
        self.notification_rules = self._setup_rules()
    
    def _setup_rules(self):
        """알림 규칙 설정"""
        return {
            "Critical": {
                "channels": ["slack", "discord", "email"],
                "immediate": True,
                "escalate_after": 30  # 30분 내 미처리시 에스컬레이션
            },
            "High": {
                "channels": ["slack"],
                "immediate": True,
                "escalate_after": 120
            },
            "Medium": {
                "channels": ["slack"],
                "immediate": False,
                "batch_interval": 3600  # 1시간마다 배치 알림
            },
            "Low": {
                "channels": [],
                "immediate": False,
                "daily_summary": True  # 일일 요약만
            }
        }
    
    async def notify_new_bug(self, bug):
        """새 버그 알림"""
        priority = bug.get("priority", "Medium")
        rule = self.notification_rules.get(priority)
        
        if not rule:
            return
        
        message = self._format_bug_message(bug)
        
        # 즉시 알림
        if rule.get("immediate"):
            if "slack" in rule["channels"] and self.slack_client:
                await self._send_slack_message(message, bug)
            
            if "discord" in rule["channels"] and self.discord_webhook:
                await self._send_discord_message(message, bug)
            
            if "email" in rule["channels"]:
                await self._send_email(message, bug)
        
        # 에스컬레이션 스케줄링
        if rule.get("escalate_after"):
            asyncio.create_task(
                self._schedule_escalation(bug, rule["escalate_after"])
            )
    
    def _format_bug_message(self, bug):
        """버그 메시지 포맷팅"""
        priority_emoji = {
            "Critical": "🚨",
            "High": "⚠️",
            "Medium": "📌",
            "Low": "ℹ️"
        }
        
        emoji = priority_emoji.get(bug.get("priority"), "🐛")
        
        message = f"""
{emoji} **새로운 버그 리포트**

**ID**: {bug['id']}
**제목**: {bug['title']}
**우선순위**: {bug.get('priority', 'Unknown')}
**카테고리**: {bug.get('category', 'Unknown')}
**담당자**: {bug.get('assigned_to', '미배정')}

**설명**: {bug['description'][:200]}...

**예상 작업 시간**: {bug.get('estimated_effort', 'N/A')}시간
**링크**: {bug.get('url', 'N/A')}
        """
        
        return message
    
    async def _send_slack_message(self, message, bug):
        """Slack 메시지 전송"""
        try:
            priority = bug.get("priority", "Medium")
            channel = "#bugs-critical" if priority == "Critical" else "#bugs"
            
            # 블록 형식으로 예쁘게 포맷팅
            blocks = [
                {
                    "type": "header",
                    "text": {
                        "type": "plain_text",
                        "text": f"🐛 {bug['title']}"
                    }
                },
                {
                    "type": "section",
                    "fields": [
                        {
                            "type": "mrkdwn",
                            "text": f"*우선순위:*\n{bug.get('priority', 'Unknown')}"
                        },
                        {
                            "type": "mrkdwn",
                            "text": f"*카테고리:*\n{bug.get('category', 'Unknown')}"
                        },
                        {
                            "type": "mrkdwn",
                            "text": f"*담당자:*\n{bug.get('assigned_to', '미배정')}"
                        },
                        {
                            "type": "mrkdwn",
                            "text": f"*예상 시간:*\n{bug.get('estimated_effort', 'N/A')}시간"
                        }
                    ]
                },
                {
                    "type": "section",
                    "text": {
                        "type": "mrkdwn",
                        "text": f"*설명:*\n{bug['description'][:300]}..."
                    }
                },
                {
                    "type": "actions",
                    "elements": [
                        {
                            "type": "button",
                            "text": {
                                "type": "plain_text",
                                "text": "이슈 보기"
                            },
                            "url": bug.get('url', '#')
                        },
                        {
                            "type": "button",
                            "text": {
                                "type": "plain_text",
                                "text": "담당하기"
                            },
                            "value": bug['id']
                        }
                    ]
                }
            ]
            
            response = self.slack_client.chat_postMessage(
                channel=channel,
                blocks=blocks,
                text=f"새 버그: {bug['title']}"  # 폴백 텍스트
            )
            
            print(f"✅ Slack 알림 전송 완료: {response['ts']}")
            
        except SlackApiError as e:
            print(f"❌ Slack 알림 실패: {e.response['error']}")
    
    async def _schedule_escalation(self, bug, delay_minutes):
        """에스컬레이션 스케줄링"""
        await asyncio.sleep(delay_minutes * 60)
        
        # 버그가 아직 미처리 상태인지 확인
        current_status = self._get_bug_status(bug['id'])
        
        if current_status == "open":
            escalation_message = f"""
🚨 **에스컬레이션 알림**

버그 {bug['id']}가 {delay_minutes}분 동안 처리되지 않았습니다!

**제목**: {bug['title']}
**우선순위**: {bug.get('priority')}
**담당자**: {bug.get('assigned_to', '미배정')}

즉시 확인이 필요합니다!
            """
            
            # 관리자에게 알림
            if self.slack_client:
                self.slack_client.chat_postMessage(
                    channel="#bugs-escalation",
                    text=escalation_message
                )
    
    async def send_daily_summary(self):
        """일일 요약 전송"""
        summary = self._generate_daily_summary()
        
        message = f"""
📊 **일일 버그 리포트 요약**

**오늘의 통계**:
- 새로운 버그: {summary['new_bugs']}개
- 해결된 버그: {summary['resolved_bugs']}개
- 진행 중: {summary['in_progress']}개
- 미해결: {summary['open_bugs']}개

**우선순위별**:
- Critical: {summary['by_priority'].get('Critical', 0)}개
- High: {summary['by_priority'].get('High', 0)}개
- Medium: {summary['by_priority'].get('Medium', 0)}개
- Low: {summary['by_priority'].get('Low', 0)}개

**Top 이슈**:
{self._format_top_issues(summary['top_issues'])}

좋은 하루 되세요! 🌟
        """
        
        if self.slack_client:
            self.slack_client.chat_postMessage(
                channel="#bugs-summary",
                text=message
            )

이제 중요한 버그가 발생하면 팀원들이 즉시 알 수 있어! 놓치는 버그가 없겠지? 🔔