custom_criteria_generator.py

"""
커스텀 심사 기준 생성 모듈
사용자 입력 기준을 바탕으로 LLM이 평가 프롬프트를 자동 생성
"""

import json
from typing import Dict, Any, List, Optional
from openai import OpenAI
import os
from dotenv import load_dotenv

load_dotenv()


class CustomCriteriaGenerator:
    """사용자 정의 심사 기준으로 LLM 프롬프트를 생성하는 클래스"""
    
    def __init__(self, api_key: Optional[str] = None):
        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
        if not self.api_key:
            raise ValueError("OPENAI_API_KEY가 설정되지 않았습니다.")
        
        self.client = OpenAI(api_key=self.api_key)
        self.model = "gpt-4o"
    
    def generate_evaluation_prompt(
        self,
        criteria_name: str,
        criteria_description: str,
        sub_criteria: List[Dict[str, Any]],
        total_points: int,
        evaluation_target: str = "workflow"  # "workflow" or "project_description"
    ) -> str:
        """
        사용자 정의 심사 기준을 바탕으로 LLM 평가 프롬프트 생성
        
        Args:
            criteria_name: 심사 기준 이름 (예: "기술적 완성도")
            criteria_description: 심사 기준 전체 설명
            sub_criteria: 세부 기준 리스트 [{"name": "이름", "description": "설명", "points": 점수}, ...]
            total_points: 총점
            evaluation_target: 평가 대상 유형 ("workflow" 또는 "project_description")
            
        Returns:
            생성된 평가 프롬프트 문자열
        """
        
        # 세부 기준 포맷팅
        sub_criteria_text = ""
        json_output_structure = {}
        
        for idx, sub in enumerate(sub_criteria, 1):
            sub_name = sub.get("name", f"기준{idx}")
            sub_desc = sub.get("description", "")
            sub_points = sub.get("points", 0)
            sub_details = sub.get("details", [])
            
            sub_criteria_text += f"\n### {criteria_name[:2]}-{idx}. {sub_name} ({sub_points}점)\n\n"
            sub_criteria_text += f"**설명:** {sub_desc}\n\n"
            
            if sub_details:
                sub_criteria_text += "**세부 평가 항목:**\n"
                detail_json = {}
                for detail in sub_details:
                    detail_name = detail.get("name", "")
                    detail_points = detail.get("points", 0)
                    detail_desc = detail.get("description", "")
                    sub_criteria_text += f"- {detail_name} ({detail_points}점): {detail_desc}\n"
                    # JSON 키를 한글로 유지하되 특수문자 제거
                    safe_key = detail_name.replace(" ", "_").replace("/", "_").replace("·", "_")
                    detail_json[safe_key] = f"<0-{detail_points}>"
                
                detail_json["소계"] = f"<0-{sub_points}>"
                detail_json["평가"] = "<구체적 평가>"
            else:
                detail_json = {
                    "점수": f"<0-{sub_points}>",
                    "평가": "<구체적 평가>"
                }
            
            # JSON 키를 한글로 유지
            safe_sub_name = sub_name.replace(" ", "_").replace("/", "_").replace("·", "_")
            json_output_structure[safe_sub_name] = detail_json
        
        json_output_structure["총점"] = f"<0-{total_points}>"
        json_output_structure["종합_평가"] = "<전체적인 평가 요약>"
        
        # 평가 대상에 따른 안내 문구
        if evaluation_target == "workflow":
            target_instruction = "워크플로우 JSON 파일을 분석하여 다음 기준으로 평가하십시오."
        else:
            target_instruction = "제출된 프로젝트 설명을 분석하여 다음 기준으로 평가하십시오."
        
        # 최종 프롬프트 생성
        prompt = f"""# {criteria_name} 심사 기준 ({total_points}점)

⚠️ **중요: 엄격한 평가 원칙**
- 점수는 매우 엄격하게 부여하십시오. 완벽하지 않으면 감점하십시오.
- "거의 완성" 또는 "대부분 좋음"은 충분하지 않습니다. 기준을 정확히 충족해야만 점수를 부여하십시오.
- 불확실하거나 명확하지 않은 경우는 낮은 점수를 부여하십시오.
- 기준을 완전히 충족하지 않으면 해당 항목에 대한 점수를 부여하지 마십시오.

{target_instruction}

## 심사 기준 설명

{criteria_description}

## 평가 항목:
{sub_criteria_text}

## 출력 형식:
JSON 형식으로 다음과 같이 출력하십시오:
{json.dumps(json_output_structure, ensure_ascii=False, indent=4)}
"""
        
        return prompt
    
    def generate_prompt_with_llm(
        self,
        criteria_name: str,
        criteria_description: str,
        sub_criteria: List[Dict[str, Any]],
        total_points: int,
        evaluation_target: str = "workflow",
        additional_context: str = ""
    ) -> str:
        """
        LLM을 사용하여 더 정교한 평가 프롬프트 생성
        
        Args:
            criteria_name: 심사 기준 이름
            criteria_description: 심사 기준 설명
            sub_criteria: 세부 기준 리스트
            total_points: 총점
            evaluation_target: 평가 대상
            additional_context: 추가 컨텍스트 (선택)
            
        Returns:
            LLM이 생성한 정교한 평가 프롬프트
        """
        
        user_input = f"""
다음 심사 기준을 바탕으로 n8n 워크플로우 평가용 프롬프트를 생성해주세요.

## 심사 기준 정보
- 기준 이름: {criteria_name}
- 총점: {total_points}점
- 평가 대상: {"워크플로우 JSON 파일" if evaluation_target == "workflow" else "프로젝트 설명서"}

## 기준 설명
{criteria_description}

## 세부 기준
{json.dumps(sub_criteria, ensure_ascii=False, indent=2)}

## 추가 컨텍스트
{additional_context if additional_context else "없음"}

위 정보를 바탕으로 LLM이 평가할 때 사용할 상세하고 구체적인 평가 프롬프트를 생성해주세요.
프롬프트에는 다음이 포함되어야 합니다:
1. 엄격한 평가 원칙
2. 각 세부 기준별 구체적인 평가 포인트
3. JSON 형식의 출력 형식 지정
4. 평가 시 주의사항
"""
        
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[
                    {
                        "role": "system",
                        "content": """당신은 n8n 워크플로우 평가 프롬프트를 설계하는 전문가입니다.
사용자가 제공하는 심사 기준을 바탕으로, LLM이 워크플로우나 프로젝트를 엄격하고 공정하게 평가할 수 있는
상세한 평가 프롬프트를 생성합니다.

프롬프트 생성 시 다음 원칙을 따르세요:
1. 각 평가 항목별로 구체적인 판단 기준 제시
2. JSON 형식으로 점수와 평가를 출력하도록 지시
3. 엄격한 평가 원칙 명시
4. 워크플로우 JSON에서 확인할 수 있는 구체적인 신호(signal) 제시
5. 평가자가 일관되게 점수를 부여할 수 있도록 명확한 기준 제공"""
                    },
                    {
                        "role": "user",
                        "content": user_input
                    }
                ],
                temperature=0.3
            )
            
            return response.choices[0].message.content
            
        except Exception as e:
            print(f"LLM 프롬프트 생성 실패: {e}")
            # 실패 시 기본 프롬프트 생성 메서드 사용
            return self.generate_evaluation_prompt(
                criteria_name, criteria_description, sub_criteria, 
                total_points, evaluation_target
            )
    
    def validate_criteria(self, sub_criteria: List[Dict[str, Any]], total_points: int) -> Dict[str, Any]:
        """
        심사 기준의 유효성 검사
        
        Args:
            sub_criteria: 세부 기준 리스트
            total_points: 명시된 총점
            
        Returns:
            검증 결과 {"valid": bool, "message": str, "calculated_total": int}
        """
        calculated_total = 0
        
        for sub in sub_criteria:
            sub_points = sub.get("points", 0)
            details = sub.get("details", [])
            
            if details:
                detail_total = sum(d.get("points", 0) for d in details)
                if detail_total != sub_points:
                    return {
                        "valid": False,
                        "message": f"'{sub.get('name', '?')}'의 세부 점수 합계({detail_total})가 소계({sub_points})와 일치하지 않습니다.",
                        "calculated_total": calculated_total
                    }
            
            calculated_total += sub_points
        
        if calculated_total != total_points:
            return {
                "valid": False,
                "message": f"세부 기준 점수 합계({calculated_total})가 총점({total_points})과 일치하지 않습니다.",
                "calculated_total": calculated_total
            }
        
        return {
            "valid": True,
            "message": "심사 기준이 유효합니다.",
            "calculated_total": calculated_total
        }


# 기본 템플릿 제공 (고정 템플릿 - 배점만 조정 가능)
FIXED_CRITERIA_TEMPLATES = {
    "기술적_완성도": {
        "name": "기술적 완성도",
        "description": "워크플로우의 구조적 완성도, 데이터 처리의 일관성, 예외 처리를 평가합니다.",
        "evaluation_target": "workflow",
        "structure": [
            {
                "name": "구조 완결성 & 모듈화",
                "description": "Trigger→Output까지 경로 완성, dead node 없음, 역할 기반 네이밍·모듈화",
                "ratio": 0.4  # 40%
            },
            {
                "name": "데이터·스키마 일관성",
                "description": "key 일관성, 불필요한 overwrite 없음, merge 정합성",
                "ratio": 0.4  # 40%
            },
            {
                "name": "분기/예외 처리",
                "description": "의미 있는 조건 분기, fallback/default 경로 존재",
                "ratio": 0.2  # 20%
            }
        ]
    },
    "업스테이지_활용도": {
        "name": "업스테이지 제품 활용도",
        "description": "업스테이지 API의 적절한 사용, 프롬프트 설계, 기능 조합을 평가합니다.",
        "evaluation_target": "workflow",
        "structure": [
            {
                "name": "API 사용 적합성",
                "description": "공식 엔드포인트, credential 보안, 목적 적합 API 선택",
                "ratio": 0.33  # 33%
            },
            {
                "name": "Prompt/System 설계",
                "description": "명확한 역할 정의, 출력 포맷 강제력, 깔끔한 프롬프트",
                "ratio": 0.33  # 33%
            },
            {
                "name": "기능 조합·오케스트레이션",
                "description": "다단계 파이프라인, 전/후처리, 효율적 호출",
                "ratio": 0.34  # 34%
            }
        ]
    }
}

# 커스터마이징 가능한 템플릿
DEFAULT_CRITERIA_TEMPLATES = {
    "실용성": {
        "name": "실용성",
        "description": "실제 업무 적용 가능성, 재사용성·확장성, 사용자 편의성을 평가합니다.",
        "total_points": 30,
        "evaluation_target": "project_description",
        "sub_criteria": [
            {
                "name": "업무 적용 가능성",
                "description": "반복 업무 제거, 실제 사용 시나리오 선명, 시간 절감 효과 명확",
                "points": 10,
                "details": [
                    {"name": "반복 업무 제거", "points": 3, "description": "매일/매주 반복되는 작업을 자동화"},
                    {"name": "실제 사용 시나리오 선명", "points": 4, "description": "누가/언제/어떻게 사용하는지 구체적"},
                    {"name": "시간 절감 효과 명확", "points": 3, "description": "정량적/질적 효과 제시"}
                ]
            },
            {
                "name": "재사용성·확장성",
                "description": "다른 데이터·조직에도 적용 가능한 일반화 구조",
                "points": 10,
                "details": [
                    {"name": "다른 데이터·조직 적용 가능", "points": 5, "description": "특정 회사/팀 종속 최소화"},
                    {"name": "확장 가능한 설계", "points": 5, "description": "새로운 요구사항 추가 시 최소 수정"}
                ]
            },
            {
                "name": "사용자 편의성",
                "description": "최종 사용자 입장에서 직관적으로 쓸 수 있는가?",
                "points": 10,
                "details": [
                    {"name": "직관적인 입력 방식", "points": 4, "description": "간단하고 명확한 입력"},
                    {"name": "명확한 출력 및 피드백", "points": 3, "description": "이해하기 쉬운 결과물"},
                    {"name": "에러 처리 및 가이드", "points": 3, "description": "사용자 친화적 메시지"}
                ]
            }
        ]
    },
    "문제해결": {
        "name": "문제 해결 접근법",
        "description": "문제 정의의 독창성과 솔루션의 참신성을 평가합니다.",
        "total_points": 30,
        "evaluation_target": "project_description",
        "sub_criteria": [
            {
                "name": "문제 정의의 독창성",
                "description": "자동화 대상 선정이 새롭거나, 실질적 문제를 잘 포착했는가? 기존 방법과 차별화된 접근을 했는가?",
                "points": 15,
                "details": [
                    {"name": "실질적 문제 포착", "points": 8, "description": "구체적 문제 상황 제시, 명확한 pain point"},
                    {"name": "차별화된 관점 및 독창성", "points": 7, "description": "기존 방식의 한계 분석, 새로운 시각"}
                ]
            },
            {
                "name": "솔루션 참신성",
                "description": "단순 API 나열이 아닌, 새로운 접근·전략 기반 설계",
                "points": 15,
                "details": [
                    {"name": "전략적 조합 및 복잡도", "points": 8, "description": "다단계 로직, 논리적 연결"},
                    {"name": "창의적 설계", "points": 7, "description": "문제 해결 특화 설계, 독특한 패턴"}
                ]
            }
        ]
    }
}


def get_fixed_template_with_points(template_name: str, total_points: int) -> Optional[Dict[str, Any]]:
    """
    고정 템플릿을 배점에 맞게 생성
    
    Args:
        template_name: "기술적_완성도" 또는 "업스테이지_활용도"
        total_points: 총 배점
        
    Returns:
        배점이 적용된 템플릿 딕셔너리
    """
    template = FIXED_CRITERIA_TEMPLATES.get(template_name)
    if not template:
        return None
    
    # 비율에 따라 배점 계산
    sub_criteria = []
    remaining_points = total_points
    
    for idx, item in enumerate(template["structure"]):
        # 마지막 항목은 남은 점수 모두 할당 (반올림 오차 방지)
        if idx == len(template["structure"]) - 1:
            points = remaining_points
        else:
            points = round(total_points * item["ratio"])
            remaining_points -= points
        
        sub_criteria.append({
            "name": item["name"],
            "description": item["description"],
            "points": points,
            "details": []
        })
    
    return {
        "name": template["name"],
        "description": template["description"],
        "total_points": total_points,
        "evaluation_target": template["evaluation_target"],
        "sub_criteria": sub_criteria
    }


def get_default_template(template_name: str) -> Optional[Dict[str, Any]]:
    """기본 템플릿 가져오기"""
    return DEFAULT_CRITERIA_TEMPLATES.get(template_name)


def list_default_templates() -> List[str]:
    """사용 가능한 기본 템플릿 목록"""
    return list(DEFAULT_CRITERIA_TEMPLATES.keys())


def list_fixed_templates() -> List[str]:
    """고정 템플릿 목록"""
    return list(FIXED_CRITERIA_TEMPLATES.keys())