Local SE Agent Masterclass

import ollama
from typing import List, Dict, Any, Optional

class OllamaLLMClient:
    """
    Wrapper ควบคุมการสื่อสารกับโมเดลภาษาในเครื่องผ่าน Ollama Daemon
    """
    def __init__(self, model_name: str = "qwen2.5-coder:7b", host: Optional[str] = None):
        self.model_name = model_name
        self.client = ollama.Client(host=host) if host else ollama.Client()

    def check_health(self) -> bool:
        """ตรวจสอบว่า daemon พร้อมใช้งานและมีโมเดลเป้าหมายอยู่หรือไม่"""
        try:
            models_response = self.client.list()
            available_models = [m.model for m in models_response.models]
            return any(self.model_name in name for name in available_models)
        except Exception:
            return False

    def chat(
        self, 
        messages: List[Dict[str, str]], 
        temperature: float = 0.2,
        json_mode: bool = False
    ) -> str:
        """
        ส่งประวัติบทสนทนาและรับข้อความตอบกลับจากโมเดล
        :param json_mode: หากเป็น True จะส่ง format="json" บังคับให้โมเดลตอบเฉพาะ JSON ไวยากรณ์เป๊ะ
        """
        try:
            # กำหนด parameters สำหรับการส่ง chat
            chat_kwargs: Dict[str, Any] = {
                "model": self.model_name,
                "messages": messages,
                "options": {"temperature": temperature}
            }

            # [จุดสำคัญของ Day 2]: ถ้าเปิด json_mode ให้ระบุ format="json"
            if json_mode:
                chat_kwargs["format"] = "json"

            response = self.client.chat(**chat_kwargs)
            return response.message.content
        except ollama.ResponseError as e:
            raise RuntimeError(f"Ollama Response Error (Status {e.status_code}): {e.error}")
        except Exception as e:
            raise ConnectionError(f"ไม่สามารถเชื่อมต่อ Ollama daemon ที่ localhost:11434 ได้: {str(e)}")

import json
import re
from typing import Dict, Any

class JSONDecodeError(Exception):
    """Custom exception สำหรับข้อผิดพลาดเมื่อผลลัพธ์ไม่สามารถ parse เป็น JSON ได้"""
    pass

class StructuredOutputParser:
    """
    ตัวจัดการถอดรหัสข้อความจากโมเดลให้กลายเป็น Python Dictionary
    พร้อมระบบ Clean Markdown Code blocks (```json ... ```)
    """

    @staticmethod
    def clean_text(raw_text: str) -> str:
        """
        ตัด Markdown code fences ออก เช่น ```json ... ``` เพื่อให้ได้สตริง JSON แท้
        """
        text = raw_text.strip()
        # ตัดแท็ก ```json หรือ ``` ที่หัวและท้ายถ้าโมเดลเผลอส่งติดมา
        if text.startswith("```"):
            text = re.sub(r"^```(?:json)?\s*", "", text, flags=re.IGNORECASE)
            text = re.sub(r"\s*```$", "", text)
        return text.strip()

    @classmethod
    def parse(cls, raw_text: str) -> Dict[str, Any]:
        """
        แปลงสตริงผลลัพธ์จาก LLM เป็น Python Dictionary
        """
        cleaned = cls.clean_text(raw_text)
        try:
            parsed_data = json.loads(cleaned)
            if not isinstance(parsed_data, dict):
                raise JSONDecodeError(f"ผลลัพธ์ไม่ได้อยู่ในรูปแบบ JSON Object (dict) แต่ได้: {type(parsed_data).__name__}")
            return parsed_data
        except json.JSONDecodeError as err:
            raise JSONDecodeError(
                f"ไม่สามารถแปลงเป็น JSON ได้: {str(err)}\n"
                f"ข้อความดิบที่ได้รับมา:\n{raw_text}"
            )

from core.client import OllamaLLMClient
from core.parser import StructuredOutputParser, JSONDecodeError

def main():
    print("🚀 เริ่มทดสอบ Day 2: Structured Outputs & JSON Mode บน Mac M3...")
    client = OllamaLLMClient(model_name="qwen2.5-coder:7b")

    if not client.check_health():
        print("❌ ข้อผิดพลาด: ไม่พบ Ollama Daemon หรือโมเดล qwen2.5-coder:7b")
        return

    # 1. กำหนด System Prompt บังคับ Schema ที่ชัดเจน
    system_instruction = (
        "You are an automated Code Reviewer. Analyze code and respond ONLY in valid JSON format.\n"
        "Schema:\n"
        "{\n"
        '  "has_bug": boolean,\n'
        '  "error_type": string,\n'
        '  "line_number": integer,\n'
        '  "suggested_fix": string\n'
        "}"
    )

    sample_bad_code = """
    def calculate_average(numbers):
        total = sum(numbers)
        return total / len(numbers) # บั๊ก: numbers อาจเป็น list ว่าง (ZeroDivisionError)
    """

    messages = [
        {"role": "system", "content": system_instruction},
        {"role": "user", "content": f"ตรวจหาบั๊กในโค้ดนี้:\n{sample_bad_code}"}
    ]

    print("📡 กำลังส่ง Prompt พร้อมเปิดใช้งาน json_mode=True...")
    raw_response = client.chat(messages, temperature=0.1, json_mode=True)
    
    print("\n--- ผลลัพธ์สตริงดิบจาก Ollama ---")
    print(raw_response)
    print("---------------------------------")

    # 2. นำไปผ่าน Structured Parser
    try:
        parsed_result = StructuredOutputParser.parse(raw_response)
        print("\n✅ Parsing สำเร็จ! ข้อมูลกลายเป็น Python Dictionary เรียบร้อย:")
        print(f"  🐞 Has Bug: {parsed_result.get('has_bug')}")
        print(f"  🏷️ Error Type: {parsed_result.get('error_type')}")
        print(f"  📍 Line Number: {parsed_result.get('line_number')}")
        print(f"  💡 Suggested Fix: {parsed_result.get('suggested_fix')}")

        # ยืนยันว่าโปรแกรมสามารถนำค่าไปเขียน Logic ต่อได้จริง
        if parsed_result.get("has_bug"):
            print("\n🎉 ยินดีด้วยครับ! โปรแกรมสามารถนำฟิลด์ 'has_bug' ไปต่อยอดใน ReAct Loop ของ Day 3 ได้แล้ว!")

    except JSONDecodeError as err:
        print(f"❌ ล้มเหลวในการ Parse: {err}")

if __name__ == "__main__":
    main()