Local SE Agent Masterclass

"""
Package รวบรวมเครื่องมือ (Tools) ปฏิบัติการของ Agent
[อัปเดต Day 10]: เพิ่ม Safe Refactoring & Rollback Engine
"""
from core.tools.file_reader import read_file, FileAccessError
from core.tools.test_runner import run_maven_test, BuildExecutionError
from core.tools.code_refactor import apply_code_patch, rollback_file, RefactorExecutionError

__all__ = [
    "read_file",
    "FileAccessError",
    "run_maven_test",
    "BuildExecutionError",
    "apply_code_patch",
    "rollback_file",
    "RefactorExecutionError"
]

import difflib
import shutil
from pathlib import Path
from typing import Dict, Any, Optional

class RefactorExecutionError(Exception):
    """Custom exception สำหรับข้อผิดพลาดระหว่างกระบวนการแก้ไขโค้ด"""
    pass

def apply_code_patch(
    filepath: str,
    new_code: str,
    workspace_root: Optional[str] = None
) -> Dict[str, Any]:
    """
    เครื่องมือสำหรับแก้ไขโค้ดอย่างปลอดภัย (Safe Code Refactor Tool):
    1. ตรวจสอบ Path Traversal Guardrail
    2. ทำสำเนา Backup ไฟล์เดิม (.bak) ทันที
    3. คำนวณ Unified Diff แสดงความเปลี่ยนแปลงแบบ Git
    4. บันทึกโค้ดใหม่ลงไฟล์เป้าหมาย
    
    :param filepath: ที่อยู่ไฟล์สัมพัทธ์ เช่น 'src/main/java/Calculator.java'
    :param new_code: เนื้อหาโค้ดใหม่ทั้งหมดที่ต้องการนำไปเขียนทับ
    :param workspace_root: โฟลเดอร์รากที่อนุญาต (ป้องกันการแก้ไฟล์นอกโฟลเดอร์)
    :return: ดิกชันนารีสรุปผลลัพธ์พร้อมข้อความ Unified Diff และ path ของไฟล์สำรอง
    """
    try:
        # 1. กำหนด Workspace Root และคำนวณ Absolute Path
        root = Path(workspace_root).resolve() if workspace_root else Path.cwd().resolve()
        target_path = (root / filepath).resolve()

        # 2. [Security Guardrail]: ป้องกัน Path Traversal
        if not str(target_path).startswith(str(root)):
            raise RefactorExecutionError(f"Security Violation: ไม่อนุญาตให้แก้ไขไฟล์นอก Workspace '{filepath}'")

        if not target_path.exists():
            raise RefactorExecutionError(f"ไม่พบไฟล์ที่ต้องการแก้ไข: '{filepath}'")

        if not target_path.is_file():
            raise RefactorExecutionError(f"พิกัด '{filepath}' เป็นโฟลเดอร์ ไม่ใช่ไฟล์")

        # 3. อ่านโค้ดดั้งเดิมออกมา
        original_code = target_path.read_text(encoding="utf-8", errors="replace")

        # 4. [Automated Backup]: สร้างสำเนาไฟล์เดิม เช่น Calculator.java.bak
        backup_path = target_path.with_suffix(target_path.suffix + ".bak")
        shutil.copyfile(target_path, backup_path)

        # 5. [Unified Diff Computation]: คำนวณความต่างของโค้ด
        # splitlines(keepends=True) เพื่อรักษาตัวแบ่งบรรทัด \n ไว้
        original_lines = original_code.splitlines(keepends=True)
        new_lines = new_code.splitlines(keepends=True)

        diff = difflib.unified_diff(
            original_lines,
            new_lines,
            fromfile=f"a/{target_path.name}",
            tofile=f"b/{target_path.name}",
            n=3  # แสดงบริบทแวดล้อม 3 บรรทัดรอบจุดแก้ไข
        )
        diff_text = "".join(diff).strip()

        # หากโค้ดไม่มีการเปลี่ยนแปลงเลย
        if not diff_text:
            return {
                "status": "unchanged",
                "message": "โค้ดใหม่เหมือนเดิมทุกประการ ไม่มีการเปลี่ยนแปลง",
                "filepath": str(target_path),
                "backup_path": str(backup_path),
                "diff": ""
            }

        # 6. บันทึกโค้ดใหม่ลงไฟล์จริง
        target_path.write_text(new_code, encoding="utf-8")

        return {
            "status": "success",
            "message": f"แก้ไขไฟล์ '{target_path.name}' สำเร็จเรียบร้อย",
            "filepath": str(target_path),
            "backup_path": str(backup_path),
            "diff": diff_text
        }

    except RefactorExecutionError:
        raise
    except Exception as err:
        raise RefactorExecutionError(f"เกิดข้อผิดพลาดในการแก้ไขไฟล์ '{filepath}': {str(err)}")

def rollback_file(filepath: str, workspace_root: Optional[str] = None) -> str:
    """
    เครื่องมือฉุกเฉินสำหรับกู้คืนไฟล์เดิมจากสำเนา (.bak)
    ใช้งานเมื่อ Agent รันเทสหลังแก้โค้ดแล้วเทสล้มเหลว
    
    :param filepath: ที่อยู่ไฟล์สัมพัทธ์
    :return: ข้อความยืนยันการกู้คืนสำเร็จ
    """
    try:
        root = Path(workspace_root).resolve() if workspace_root else Path.cwd().resolve()
        target_path = (root / filepath).resolve()
        backup_path = target_path.with_suffix(target_path.suffix + ".bak")

        if not backup_path.exists():
            raise RefactorExecutionError(f"ไม่พบไฟล์สำรอง (.bak) สำหรับ: '{filepath}'")

        # ก๊อปปี้ไฟล์สำรองกลับมาทับไฟล์จริง
        shutil.copyfile(backup_path, target_path)

        return f"⏪ สำเร็จ: กู้คืนไฟล์ '{target_path.name}' จากสำเนาเรียบร้อย โค้ดกลับสู่สถานะปลอดภัยเดิม 100%"

    except Exception as err:
        raise RefactorExecutionError(f"ล้มเหลวในการกู้คืนไฟล์ '{filepath}': {str(err)}")

import shutil
from pathlib import Path
from core.tools.code_refactor import apply_code_patch, rollback_file

def main():
    print("🚀 เริ่มทดสอบ Day 10: Safe Refactor & Unified Diff Patching บน Mac M3...")

    mock_dir = Path("./temp_refactor_test").resolve()
    mock_dir.mkdir(parents=True, exist_ok=True)
    target_file = mock_dir / "Calculator.java"

    try:
        # 1. สร้างไฟล์โค้ดต้นฉบับที่มีบั๊ก (ลดราคาคูณ 2 ผิดสูตร)
        initial_code = (
            "public class Calculator {\n"
            "    public double applyDiscount(double price, double discount) {\n"
            "        // บั๊กเดิม: ลบส่วนลด 2 เท่า\n"
            "        return price - (discount * 2.0);\n"
            "    }\n"
            "}\n"
        )
        target_file.write_text(initial_code, encoding="utf-8")
        print(f"📁 1. สร้างไฟล์ทดสอบที่: {target_file.name}")

        # 2. เตรียมโค้ดแก้ไขที่ถูกต้อง
        fixed_code = (
            "public class Calculator {\n"
            "    public double applyDiscount(double price, double discount) {\n"
            "        // แก้ไขถูกต้อง: ลบส่วนลดตามจริง\n"
            "        return price - discount;\n"
            "    }\n"
            "}\n"
        )

        print("\n" + "=" * 60)
        print("🛠️ 2. ดำเนินการแก้ไขโค้ดด้วย apply_code_patch():")
        print("=" * 60)

        # 3. สั่ง Patch โค้ด
        result = apply_code_patch(
            filepath="Calculator.java",
            new_code=fixed_code,
            workspace_root=str(mock_dir)
        )

        print(f"✅ สถานะ: {result['status']}")
        print(f"💾 สำเนาถูกสร้างที่: {Path(result['backup_path']).name}")
        print("\n🔍 แสดง Unified Diff Preview (สิ่งที่เปลี่ยนไป):")
        print("-" * 50)
        # แสดง Diff สีสันจำลอง
        for line in result["diff"].splitlines():
            if line.startswith("+"):
                print(f"\033[92m{line}\033[0m")  # สีเขียว = เพิ่ม
            elif line.startswith("-"):
                print(f"\033[91m{line}\033[0m")  # สีแดง = ลบ
            else:
                print(line)
        print("-" * 50)

        # ตรวจสอบว่าโค้ดใหม่ถูกเขียนจริง
        current_content = target_file.read_text(encoding="utf-8")
        assert "return price - discount;" in current_content, "❌ โค้ดใหม่ไม่ถูกบันทึก!"
        assert (mock_dir / "Calculator.java.bak").exists(), "❌ ไม่พบไฟล์ Backup!"
        print("🎉 Patch โค้ดสำเร็จสมบูรณ์ 100%!")

        # 4. ทดสอบระบบ Rollback ฉุกเฉิน
        print("\n" + "=" * 60)
        print("⏪ 3. ทดสอบระบบ Rollback ฉุกเฉิน (สมมติว่าเทสล้มเหลว):")
        print("=" * 60)
        rollback_msg = rollback_file("Calculator.java", workspace_root=str(mock_dir))
        print(rollback_msg)

        # ตรวจสอบว่าโค้ดกลับมาเป็นแบบเดิมจริงไหม
        restored_content = target_file.read_text(encoding="utf-8")
        assert "return price - (discount * 2.0);" in restored_content, "❌ การ Rollback ล้มเหลว!"
        print("✅ การันตี 100%: โค้ดเดิมถูกกู้คืนกลับมาอย่างแม่นยำ ปลอดภัยไร้ความเสี่ยง!")

    finally:
        # ทำความสะอาดโฟลเดอร์ทดสอบ
        shutil.rmtree(mock_dir, ignore_errors=True)

if __name__ == "__main__":
    main()