CodeMidas 2026: Arsitektur Penskalaan Lingkungan RL Coding Agent Langsung dari Kode Sumber (Code Itself), 6-Container Verification, dan Analisis Perilaku Eksplorasi Multi-Turn

"""
CodeMidas Architecture: Agentic Synthesis of Coding RL Environments Directly from Source Code.
Berdasarkan Makalah Frontier arXiv:2609.22068 (Xiaomi LLM Core, PKU, HKU, September 2026).

Komponen Inti:
1. Codebase Scope Slicer: Memisahkan fungsionalitas publik & dependensi internal.
2. Anti-Overspecification Test Reviewer: Menghapus pengecekan incidental (string formatting/order) 
   menjadi murni behavioral assertion.
3. 6-Container Execution Consistency Validator: Menjalankan 2x starting-state (keduanya WAJIB gagal) 
   dan 4x reference-state (keempatnya WAJIB lulus).
4. Adversarial Leakage Prober: Mengecek residual artifact pada disk/cache yang berpotensi 
   dieksploitasi solver agent untuk bypass coding.
"""

import os
import shutil
import subprocess
from dataclasses import dataclass, field
from enum import Enum
from typing import Dict, List, Optional, Tuple

class TaskInterfaceType(Enum):
    CLI_TOOL = "cli_tool"
    PURE_FUNCTION = "pure_function"
    STATEFUL_API = "stateful_api"

@dataclass
class CodeMidasTaskSpecification:
    task_id: str
    codebase_name: str
    language: str
    domain: str
    interface_type: TaskInterfaceType
    task_statement: str
    public_entry_points: List[str]
    reference_solution_diff: str
    starting_codebase_path: str
    reference_codebase_path: str
    generated_test_suite_path: str

@dataclass
class ExecutionConsistencyResult:
    starting_runs_passed: int # Target: 0 (Semua 2 run harus gagal)
    starting_runs_failed: int # Target: 2
    reference_runs_passed: int # Target: 4 (Semua 4 run harus lulus)
    reference_runs_failed: int # Target: 0
    is_deterministic: bool

class AntiOverspecificationVerifier:
    """
    Meninjau setiap asersi uji agar tidak memaksakan implementasi privat atau
    formatting teks incidental yang tidak tertuang pada spesifikasi tugas.
    """
    @staticmethod
    def audit_assertion(assertion_ast_node: dict, statement_spec: str) -> bool:
        forbidden_patterns = [
            "__private_member",
            "exact_error_string_match",
            "dict_keys_ordering_strict",
            "internal_cache_dict_inspect"
        ]
        for pattern in forbidden_patterns:
            if pattern in assertion_ast_node.get("source_code", ""):
                # Tolak jika asersi memeriksa internal privat repositori
                return False
        return True

class CodeMidasEnvironmentHarness:
    def __init__(self, task: CodeMidasTaskSpecification):
        self.task = task
        self.base_container_image = f"newsaint-rl-sandbox:{task.language.lower()}-v1"

    def run_isolated_container(self, codebase_path: str, test_path: str, container_idx: int) -> Tuple[bool, str]:
        """
        Menjalankan pengujian dalam isolated container runtime (gVisor/bwrap sandbox).
        Mengembalikan verdict sukses (True/False) dan stdout/stderr logs.
        """
        # Simulasi eksekusi sandboxed deterministic
        cmd = [
            "docker", "run", "--rm",
            "--network", "none",
            "--memory", "4g",
            "--cpus", "2.0",
            "-v", f"{os.path.abspath(codebase_path)}:/workspace/repo:ro",
            "-v", f"{os.path.abspath(test_path)}:/workspace/tests/verifier.py:ro",
            self.base_container_image,
            "python3", "-m", "pytest", "/workspace/tests/verifier.py"
        ]
        try:
            res = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
            return (res.returncode == 0, res.stdout)
        except subprocess.TimeoutExpired:
            return (False, "EXECUTION_TIMEOUT_EXCEEDED")
        except Exception as e:
            return (False, str(e))

    def evaluate_six_container_consistency(self) -> ExecutionConsistencyResult:
        """
        Protokol 6-Container CodeMidas:
        - 2 Container dijalankan dengan kode awal (starting codebase). Keduanya WAJIB gagal.
        - 4 Container dijalankan dengan solusi referensi. Keempatnya WAJIB lulus.
        """
        starting_fails = 0
        starting_passes = 0
        for i in range(2):
            passed, _ = self.run_isolated_container(
                self.task.starting_codebase_path,
                self.task.generated_test_suite_path,
                container_idx=i
            )
            if passed:
                starting_passes += 1
            else:
                starting_fails += 1

        reference_passes = 0
        reference_fails = 0
        for i in range(4):
            passed, _ = self.run_isolated_container(
                self.task.reference_codebase_path,
                self.task.generated_test_suite_path,
                container_idx=i + 2
            )
            if passed:
                reference_passes += 1
            else:
                reference_fails += 1

        is_deterministic = (starting_fails == 2 and reference_passes == 4)
        return ExecutionConsistencyResult(
            starting_runs_passed=starting_passes,
            starting_runs_failed=starting_fails,
            reference_runs_passed=reference_passes,
            reference_runs_failed=reference_fails,
            is_deterministic=is_deterministic
        )

    def probe_adversarial_leakage(self, sandbox_workspace_path: str) -> bool:
        """
        Adversarial Leakage Audit: Memastikan tidak ada byte-compiled (.pyc), cache,
        atau sisa log konstruksi yang membeberkan kode solusi referensi kepada agen RL.
        """
        forbidden_leak_indicators = [
            ".git/logs",
            "__pycache__",
            ".pytest_cache",
            "dist/",
            "build/",
            ".reference_backup"
        ]
        for root, dirs, files in os.walk(sandbox_workspace_path):
            for d in dirs:
                full_dir = os.path.join(root, d)
                if any(ind in full_dir for ind in forbidden_leak_indicators):
                    return True # Kebocoran ditemukan!
            for f in files:
                if f.endswith((".pyc", ".so", ".o", ".dylib")):
                    return True # Residual binary ditemukan!
        return False