Upload folder using huggingface_hub

server/QUESTIONS.JSON

@@ -0,0 +1,52 @@
+{
+  "1": {"lang": "Python", "task": "Fix Python 2 Print", "context": "print 'Hello World'", "ans": "print("},
+  "2": {"lang": "Python", "task": "Missing Colon in If", "context": "if True print('Success')", "ans": "True:"},
+  "3": {"lang": "Python", "task": "Indentation Error", "context": "def f():\nreturn 1", "ans": "    return"},
+  "4": {"lang": "JavaScript", "task": "Const Reassignment", "context": "const x=10; x=20;", "ans": "let x"},
+  "5": {"lang": "JavaScript", "task": "Strict Equality", "context": "if (x == '5')", "ans": "==="},
+  "6": {"lang": "Python", "task": "Import Error", "context": "from math import floor_div", "ans": "floor"},
+  "7": {"lang": "Java", "task": "Missing Semicolon", "context": "int x = 5", "ans": "5;"},
+  "8": {"lang": "Java", "task": "String Comparison", "context": "if (str == 'admin')", "ans": ".equals("},
+  "9": {"lang": "Python", "task": "List Appending", "context": "my_list.add(5)", "ans": ".append("},
+  "10": {"lang": "Python", "task": "JSON Loads Logic", "context": "json.load('{\"a\":1}')", "ans": "json.loads"},
+  "11": {"lang": "C++", "task": "Pointer Syntax", "context": "int x = 5; int ptr = &x;", "ans": "int*"},
+  "12": {"lang": "Python", "task": "Mutable Default Arg", "context": "def f(a=[])", "ans": "None"},
+  "13": {"lang": "JavaScript", "task": "Template Literal", "context": "'Value: ' + x", "ans": "`${x}`"},
+  "14": {"lang": "Python", "task": "Type Error", "context": "len(555)", "ans": "str(555)"},
+  "15": {"lang": "Python", "task": "Dictionary Access", "context": "d.key", "ans": "d['key']"},
+  "16": {"lang": "C++", "task": "Namespace Missing", "context": "cout << 'Hi';", "ans": "std::cout"},
+  "17": {"lang": "Python", "task": "F-String Syntax", "context": "f'Val is {x'", "ans": "{x}"},
+  "18": {"lang": "JavaScript", "task": "Undefined Check", "context": "if (x = undefined)", "ans": "==="},
+  "19": {"lang": "Python", "task": "Except Block", "context": "except Error, e:", "ans": "as e:"},
+  "20": {"lang": "Rust", "task": "Ownership/Borrow", "context": "let s2 = s1;", "ans": ".clone()"},
+  "21": {"lang": "Python", "task": "Range Logic", "context": "range(10, 0)", "ans": "-1"},
+  "22": {"lang": "Java", "task": "Main Method", "context": "void main(String args)", "ans": "static"},
+  "23": {"lang": "Python", "task": "Open File Mode", "context": "open('f.txt', 'r').write()", "ans": "'w'"},
+  "24": {"lang": "JavaScript", "task": "Async Missing", "context": "await fetch(url)", "ans": "async"},
+  "25": {"lang": "Python", "task": "Class Init", "context": "def init(self):", "ans": "__init__"},
+  "26": {"lang": "C++", "task": "Vector Access", "context": "v.at[0]", "ans": "v[0]"},
+  "27": {"lang": "Python", "task": "Set Literal", "context": "s = {1, 1, 2}", "ans": "{1, 2}"},
+  "28": {"lang": "JavaScript", "task": "Arrow Function", "context": "func = () => { x }", "ans": "return"},
+  "29": {"lang": "Java", "task": "Boolean Value", "context": "boolean b = 1;", "ans": "true"},
+  "30": {"lang": "Python", "task": "Super Call", "context": "super.init()", "ans": "super().__init__"},
+  "31": {"lang": "Python", "task": "Global Keyword", "context": "x = 10; def f(): x = 5", "ans": "global x"},
+  "32": {"lang": "JavaScript", "task": "Map Return", "context": "arr.map(x => { x * 2 })", "ans": "return"},
+  "33": {"lang": "Python", "task": "Lambda Syntax", "context": "lambda x: return x", "ans": "x: x"},
+  "34": {"lang": "Java", "task": "Final Variable", "context": "final int x = 1; x = 2;", "ans": "int x"},
+  "35": {"lang": "Python", "task": "Init Self Missing", "context": "def __init__():", "ans": "(self)"},
+  "36": {"lang": "C++", "task": "Memory Leak", "context": "int* p = new int[5];", "ans": "delete[]"},
+  "37": {"lang": "Python", "task": "Zip Unpack", "context": "for a, b in zip(l1)", "ans": "l1, l2"},
+  "38": {"lang": "JavaScript", "task": "Nullish Coalescing", "context": "x || 'default'", "ans": "??"},
+  "39": {"lang": "Python", "task": "Format Specifier", "context": "'%.2f' % 'str'", "ans": "1.23"},
+  "40": {"lang": "Java", "task": "Inheritance", "context": "class A implements B", "ans": "extends"},
+  "41": {"lang": "Python", "task": "Docstring", "context": "'This is doc' def f():", "ans": "def f():\n    \"\"\""},
+  "42": {"lang": "JavaScript", "task": "Promise Resolve", "context": "new Promise((res) => res)", "ans": "res()"},
+  "43": {"lang": "Python", "task": "Sort Key", "context": "list.sort(key=None)", "ans": "lambda"},
+  "44": {"lang": "C++", "task": "For Loop Iterator", "context": "for(i=0; i<5; i++)", "ans": "int i"},
+  "45": {"lang": "Python", "task": "Regex Escape", "context": "re.search('\\d', s)", "ans": "r'\\d'"},
+  "46": {"lang": "Java", "task": "ArrayList Type", "context": "List<int> l;", "ans": "Integer"},
+  "47": {"lang": "Python", "task": "Static Method", "context": "def f(self):", "ans": "@staticmethod"},
+  "48": {"lang": "JavaScript", "task": "Module Export", "context": "export f(){}", "ans": "export function"},
+  "49": {"lang": "Python", "task": "Async Loop", "context": "for x in async_gen():", "ans": "async for"},
+  "50": {"lang": "Python", "task": "Final Challenge", "context": "eval(input())", "ans": "ast.literal_eval"}
+}

server/lint_coding_agent_environment.py

@@ -11,6 +11,8 @@ A simple test environment that echoes back messages sent to it.
 Perfect for testing HTTP server infrastructure.
 """
 
+import json
+import os
 from uuid import uuid4
 from openenv.core.env_server.interfaces import Environment
 from openenv.core.env_server.types import State
@@ -20,68 +22,76 @@ try:
 except ImportError:
     from models import LintCodingAgentAction, LintCodingAgentObservation
 
-# MANDATORY: Real-world task data for Level 1, 10, and 20 (Easy, Medium, Hard)
-CURRICULUM = {
-    1: {"lang": "Python", "task": "Fix Syntax: Python 2 to 3", "context": "print 'Hello'", "ans": "print("},
-    10: {"lang": "Python", "task": "Libraries: Fix JSON load", "context": "json.load('{\"a\":1}')", "ans": "json.loads"},
-    20: {"lang": "Python", "task": "Optimization: Use Set lookup", "context": "if x in [1,2,3]:", "ans": "set(["},
-}
-
 class LintCodingAgentEnvironment(Environment):
+    """
+    A data-driven environment that loads a 50-level curriculum from a JSON file.
+    Designed for professional code-linting agent evaluation.
+    """
     SUPPORTS_CONCURRENT_SESSIONS: bool = True
 
     def __init__(self):
         # Initialize internal state using OpenEnv's State object
         self._state = State(episode_id=str(uuid4()), step_count=0)
         self.level = 1
-        self.max_levels = 20
+        
+        # --- DATA LOADING BLOCK ---
+        # Get the path to QUESTIONS.json relative to this file to avoid pathing errors in Docker
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        json_path = os.path.join(current_dir, "QUESTIONS.json")
+        
+        try:
+            with open(json_path, "r") as f:
+                self.curriculum = json.load(f)
+        except Exception as e:
+            print(f"CRITICAL ERROR: Could not load QUESTIONS.json: {e}")
+            # Minimal fallback to prevent total server crash
+            self.curriculum = {"1": {"lang": "Python", "task": "Fallback", "context": "print 'Hi'", "ans": "print("}}
+        
+        self.max_levels = len(self.curriculum)
 
     def reset(self) -> LintCodingAgentObservation:
-        """Reset the environment to the first level."""
+        """Reset the environment to the beginning of the curriculum."""
         self._state = State(episode_id=str(uuid4()), step_count=0)
         self.level = 1
-        return self._get_observation("Environment ready! Resolve Level 1.", 0.0, False)
+        return self._get_observation("Curriculum Loaded. Ready for Level 1.", 0.0, False)
 
     def step(self, action: LintCodingAgentAction) -> LintCodingAgentObservation:
-        """Process the agent's code solution and return a strict observation."""
+        """Process the agent's solution against the current JSON task."""
         self._state.step_count += 1
         
-        # 1. GET CURRENT TASK
-        goal = CURRICULUM.get(self.level, CURRICULUM[1])
+        # Get current level data (JSON keys are strings)
+        task_data = self.curriculum.get(str(self.level), self.curriculum.get("1"))
         
-        # 2. THE GRADER 
-        # Accessing 'code_solution' and 'explanation' from your strict Action model
+        # Logic: Extract fields from the strict Action model
         solution = action.code_solution
         explanation = action.explanation
         
-        # Case-insensitive check for the required fix keyword
-        is_correct = goal["ans"].lower() in solution.lower()
+        # Case-insensitive grading logic
+        is_correct = task_data["ans"].lower() in solution.lower()
         
-        # 3. REWARD LOGIC
         if is_correct:
             reward = 1.0
             self.level += 1
-            feedback = f"Correct! Level {self.level - 1} cleared. Reasoning noted: {explanation}"
+            feedback = f"Correct! Level {self.level - 1} cleared. Reason: {explanation}"
         else:
             reward = -0.1
-            feedback = f"Incorrect. Retry Level {self.level}. Hint: {goal['task']}"
+            feedback = f"Incorrect fix. Retry Level {self.level}. Hint: {task_data['task']}"
 
-        # 4. DONE CRITERIA
-        # Finish if max levels hit or if the agent explicitly quits
+        # Done if all levels complete or agent gives up
         done = self.level > self.max_levels or "QUIT" in solution.upper()
 
         return self._get_observation(feedback, reward, done)
 
     def _get_observation(self, feedback: str, reward: float, done: bool) -> LintCodingAgentObservation:
-        """Helper to package internal state into the Pydantic Observation model."""
-        goal = CURRICULUM.get(self.level, CURRICULUM[1])
+        """Helper to package internal data into the strict Observation Pydantic model."""
+        # Use string indexing for JSON curriculum access
+        task_data = self.curriculum.get(str(self.level), self.curriculum.get("1"))
         
-        # This MUST match the fields in your LintCodingAgentObservation exactly
         return LintCodingAgentObservation(
             level=self.level,
-            language=goal["lang"],
-            problem_statement=f"{feedback} | Task: {goal['task']}",
-            code_context=goal["context"],
+            language=task_data["lang"],
+            problem_statement=f"{feedback} | Goal: {task_data['task']}",
+            code_context=task_data["context"],
             last_test_results=feedback,
             reward=reward,
             done=done,