Upload folder using huggingface_hub

inference.py

@@ -0,0 +1,79 @@
+"""
+Baseline inference script for code_review_env.
+Uses OpenAI API to run an agent against all 3 tasks.
+"""
+import os
+import json
+import requests
+from openai import OpenAI
+
+BASE_URL = os.getenv("ENV_URL", "http://localhost:8000")
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY", "dummy-key"))
+
+TASKS = ["easy", "medium", "hard"]
+
+def run_task(task_id: str) -> float:
+    # Reset environment
+    reset_resp = requests.post(f"{BASE_URL}/reset", json={"task_id": task_id})
+    obs = reset_resp.json()["observation"]
+    
+    code_snippet = obs["code_snippet"]
+    task_description = obs["task_description"]
+    
+    # Call LLM
+    prompt = f"""You are a code reviewer. {task_description}
+
+Code to review:
+```python
+{code_snippet}
+```
+
+Respond ONLY with valid JSON, no markdown:
+{{
+  "review": "your detailed analysis",
+  "bug_type": "syntax or logic or security or none",
+  "line_number": <integer>,
+  "confidence": <float 0.0-1.0>
+}}"""
+
+    try:
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.0,
+        )
+        raw = response.choices[0].message.content.strip()
+        raw = raw.replace("```json", "").replace("```", "").strip()
+        action = json.loads(raw)
+    except Exception as e:
+        print(f"LLM error for {task_id}: {e}")
+        action = {"review": "unknown", "bug_type": "none", "line_number": -1, "confidence": 0.0}
+
+    # Step
+    step_resp = requests.post(f"{BASE_URL}/step", json={"action": action})
+    step_data = step_resp.json()
+    
+    # Get grader score
+    grader_resp = requests.get(f"{BASE_URL}/grader?task_id={task_id}&episode_id=baseline")
+    score = grader_resp.json().get("score", 0.0)
+    
+    print(f"Task: {task_id} | Score: {score} | Feedback: {step_data['observation'].get('previous_feedback', '')}")
+    return score
+
+def main():
+    scores = {}
+    for task_id in TASKS:
+        scores[task_id] = run_task(task_id)
+    
+    average = sum(scores.values()) / len(scores)
+    scores["average"] = round(average, 4)
+    
+    print(f"\nBaseline Results: {json.dumps(scores, indent=2)}")
+    
+    with open("baseline_scores.json", "w") as f:
+        json.dump(scores, f, indent=2)
+    
+    return scores
+
+if __name__ == "__main__":
+    main()

models.py

@@ -30,6 +30,7 @@ class ReviewObservation(Observation):
     attempt_number: int            # how many steps taken so far
     previous_feedback: str         # feedback from last step, empty on reset
     done: bool                     # whether episode is complete
+    hint: Optional[str] = None     # optional hint for the agent
 
 
 class ReviewState(State):
@@ -42,3 +43,4 @@ class ReviewState(State):
     step_count: int = 0
     task_episode_id: str = ""
     cumulative_reward: float = 0.0
+    total_snippets: int = 4

openenv.yaml

@@ -4,4 +4,6 @@ type: space
 runtime: fastapi
 app: server.app:app
 port: 8000
+version: "1.0.0"
+description: "AI agent environment for Python code review across syntax, logic, and security bug detection"
 

server/app.py

@@ -34,6 +34,12 @@ def list_tasks():
                     "bug_type": "string - syntax | logic | security | none",
                     "line_number": "int - line with the bug, -1 if unknown",
                     "confidence": "float - your confidence 0.0 to 1.0"
+                },
+                "example_action": {
+                    "review": "Line 1 is missing a colon after the function definition. This is a syntax error.",
+                    "bug_type": "syntax",
+                    "line_number": 1,
+                    "confidence": 0.95
                 }
             },
             {
@@ -45,6 +51,12 @@ def list_tasks():
                     "bug_type": "string - syntax | logic | security | none",
                     "line_number": "int - line with the bug, -1 if unknown",
                     "confidence": "float - your confidence 0.0 to 1.0"
+                },
+                "example_action": {
+                    "review": "Line 5 has an index error: it should be max_val = numbers[i], not numbers[i - 1]. This is a logic bug.",
+                    "bug_type": "logic",
+                    "line_number": 5,
+                    "confidence": 0.95
                 }
             },
             {
@@ -56,11 +68,31 @@ def list_tasks():
                     "bug_type": "string - syntax | logic | security | none",
                     "line_number": "int - line with the bug, -1 if unknown",
                     "confidence": "float - your confidence 0.0 to 1.0"
+                },
+                "example_action": {
+                    "review": "Line 6 has a SQL injection vulnerability because the username is concatenated directly into the query without parameterized statements.",
+                    "bug_type": "security",
+                    "line_number": 6,
+                    "confidence": 0.95
                 }
             }
         ]
     }
 
+@app.get("/info")
+def info():
+    """
+    Returns information about the Code Review Environment.
+    Returns: environment name, version, description, number of tasks, and supported difficulty levels
+    """
+    return {
+        "name": "code_review_env",
+        "version": "1.0.0",
+        "description": "AI agent environment for Python code review across syntax, logic, and security bug detection",
+        "num_tasks": 3,
+        "difficulty_levels": ["easy", "medium", "hard"]
+    }
+
 @app.get("/grader")
 def grader(task_id: str = Query("easy"), episode_id: str = Query(None)):
     """

server/code_review_env_environment.py

@@ -11,6 +11,7 @@ Code Review Environment — agent finds bugs in Python snippets.
 
 from __future__ import annotations
 import uuid
+import random
 from openenv.core.env_server.interfaces import Environment, Action, Observation
 from models import ReviewAction, ReviewObservation, ReviewState
 # ── Task bank ────────────────────────────────────────────────────────────────
@@ -22,7 +23,9 @@ TASKS = {
             "runtime errors. Specify the bug type, the line number where "
             "the error occurs, and explain what is wrong."
         ),
-        "snippet": """\
+        "snippets": [
+            {
+                "code": """\
 def calculate_average(numbers)
     total = 0
     for num in numbers:
@@ -32,8 +35,50 @@ def calculate_average(numbers)
 result = calculate_average([10, 20, 30])
 print(result)
 """,
+                "bug_type": "syntax",
+                "line_number": 1,
+                "keywords": ["colon", "missing", "def", "syntax"],
+            },
+            {
+                "code": """\
+def add_numbers(a, b)
+    return a + b
+
+result = add_numbers(5, 10)
+print(result)
+""",
+                "bug_type": "syntax",
+                "line_number": 1,
+                "keywords": ["colon", "missing", "syntax"],
+            },
+            {
+                "code": """\
+def greet(name):
+    message = "Hello " + name
+    print(message)
+    # Missing return statement here
+
+greet("Alice")
+""",
+                "bug_type": "syntax",
+                "line_number": 4,
+                "keywords": ["return", "missing", "runtime"],
+            },
+            {
+                "code": """\
+def process_data(data):
+    result = process(data)
+    return result
+
+result_value = process_data([1, 2, 3])
+print(result_value)
+""",
+                "bug_type": "syntax",
+                "line_number": 2,
+                "keywords": ["undefined", "name", "not defined"],
+            },
+        ],
         "correct_bug_type": "syntax",
-        "correct_line_number": 1,
         "correct_keywords": ["colon", "missing", "def", "syntax"],
     },
     "medium": {
@@ -42,7 +87,9 @@ print(result)
             "but produces incorrect output. Identify the logic bug, "
             "the line number, and explain why it is wrong."
         ),
-        "snippet": """\
+        "snippets": [
+            {
+                "code": """\
 def find_max(numbers):
     max_val = numbers[0]
     for i in range(len(numbers)):
@@ -52,8 +99,56 @@ def find_max(numbers):
 
 print(find_max([3, 7, 2, 9, 4]))
 """,
+                "bug_type": "logic",
+                "line_number": 5,
+                "keywords": ["index", "i - 1", "off by one", "wrong", "logic"],
+            },
+            {
+                "code": """\
+def count_matches(lst, target):
+    count = 0
+    for item in lst:
+        if item = target:
+            count += 1
+    return count
+
+print(count_matches([1, 2, 2, 3, 2], 2))
+""",
+                "bug_type": "logic",
+                "line_number": 4,
+                "keywords": ["comparison", "==", "assignment", "operator"],
+            },
+            {
+                "code": """\
+def reverse_string(s):
+    result = ""
+    for i in range(len(s) - 1, -1, -1):
+        for j in range(0, len(s)):
+            result += s[j]
+    return result
+
+print(reverse_string("hello"))
+""",
+                "bug_type": "logic",
+                "line_number": 3,
+                "keywords": ["loop", "bounds", "reversed", "range"],
+            },
+            {
+                "code": """\
+def extract_substring(text):
+    start = 5
+    end = 2
+    return text[start:end]
+
+result = extract_substring("Hello World")
+print(result)
+""",
+                "bug_type": "logic",
+                "line_number": 4,
+                "keywords": ["slice", "index", "string", "wrong"],
+            },
+        ],
         "correct_bug_type": "logic",
-        "correct_line_number": 5,
         "correct_keywords": ["index", "i - 1", "off by one", "wrong", "logic"],
     },
     "hard": {
@@ -62,7 +157,9 @@ print(find_max([3, 7, 2, 9, 4]))
             "Identify the vulnerability type, the line number, and explain "
             "the security risk it introduces."
         ),
-        "snippet": """\
+        "snippets": [
+            {
+                "code": """\
 import sqlite3
 
 def get_user(username):
@@ -75,8 +172,57 @@ def get_user(username):
 user_input = input("Enter username: ")
 print(get_user(user_input))
 """,
+                "bug_type": "security",
+                "line_number": 6,
+                "keywords": ["sql injection", "injection", "concatenat", "unsanitized", "parameterized"],
+            },
+            {
+                "code": """\
+def authenticate(username, password):
+    admin_password = "SuperSecret123!"
+    
+    if username == "admin" and password == admin_password:
+        return True
+    return False
+
+user_input = input("Username: ")
+pass_input = input("Password: ")
+print(authenticate(user_input, pass_input))
+""",
+                "bug_type": "security",
+                "line_number": 2,
+                "keywords": ["hardcoded", "password", "credentials", "secret", "plaintext"],
+            },
+            {
+                "code": """\
+import pickle
+
+def deserialize_data(data):
+    return pickle.loads(data)
+
+received_data = input("Enter pickled data: ")
+result = deserialize_data(received_data.encode())
+print(result)
+""",
+                "bug_type": "security",
+                "line_number": 4,
+                "keywords": ["pickle", "untrusted", "deserialize", "arbitrary code"],
+            },
+            {
+                "code": """\
+def evaluate_expression(expr):
+    result = eval(expr)
+    return result
+
+user_expr = input("Enter expression: ")
+print(evaluate_expression(user_expr))
+""",
+                "bug_type": "security",
+                "line_number": 2,
+                "keywords": ["eval", "arbitrary code", "user input", "dangerous"],
+            },
+        ],
         "correct_bug_type": "security",
-        "correct_line_number": 6,
         "correct_keywords": ["sql injection", "injection", "concatenat", "unsanitized", "parameterized"],
     },
 }
@@ -125,14 +271,19 @@ def compute_reward(action: ReviewAction, task: dict, attempt: int) -> tuple[floa
     else:
         feedback_parts.append("✗ Explanation missing key concepts.")
 
+    # Semantic similarity bonus (+0.25): if review length > 50 chars AND contains correct keyword
+    if len(action.review) > 50 and matched_keywords:
+        reward += 0.25
+        feedback_parts.append("✓ Semantic similarity bonus: detailed and accurate explanation.")
+
     # Retry penalty
     if attempt > 1:
         penalty = 0.1 * (attempt - 1)
         reward -= penalty
         feedback_parts.append(f"⚠ Retry penalty: -{penalty:.1f}")
 
-    # Clamp to 0.0-1.0 (max raw = 2.0, normalize)
-    normalized = max(0.0, min(1.0, reward / 2.0))
+    # Clamp to 0.0-1.0 (max raw = 2.25, normalize)
+    normalized = max(0.0, min(1.0, reward / 2.25))
     return round(normalized, 4), " ".join(feedback_parts)
 
 
@@ -151,23 +302,28 @@ class CodeReviewEnvironment(Environment):
         if task_id not in TASKS:
             task_id = "easy"
         task = TASKS[task_id]
+        # Randomly select a snippet from the available snippets
+        selected_snippet = random.choice(task["snippets"])
+        
         self._state = ReviewState(
             current_task_id=task_id,
-            current_snippet=task["snippet"],
-            correct_bug_type=task["correct_bug_type"],
-            correct_line_number=task["correct_line_number"],
-            correct_keywords=task["correct_keywords"],
+            current_snippet=selected_snippet["code"],
+            correct_bug_type=selected_snippet["bug_type"],
+            correct_line_number=selected_snippet["line_number"],
+            correct_keywords=selected_snippet["keywords"],
             step_count=0,
             task_episode_id=str(uuid.uuid4()),
             cumulative_reward=0.0,
+            total_snippets=len(task["snippets"]),
         )
         return ReviewObservation(
-            code_snippet=task["snippet"],
+            code_snippet=selected_snippet["code"],
             task_description=task["description"],
             task_id=task_id,
             attempt_number=0,
             previous_feedback="",
             done=False,
+            hint=None,
         )
 
     def step(self, action: Action) -> Observation:
@@ -175,7 +331,14 @@ class CodeReviewEnvironment(Environment):
             raise ValueError(f"Expected ReviewAction, got {type(action)}")
 
         self._state.step_count += 1
-        task = TASKS[self._state.current_task_id]
+        task_base = TASKS[self._state.current_task_id]
+        
+        # Create task dict with current snippet's correct answers for compute_reward
+        task = {
+            "correct_bug_type": self._state.correct_bug_type,
+            "correct_line_number": self._state.correct_line_number,
+            "correct_keywords": self._state.correct_keywords,
+        }
 
         reward, feedback = compute_reward(
             action, task, self._state.step_count
@@ -189,11 +352,12 @@ class CodeReviewEnvironment(Environment):
 
         return ReviewObservation(
             code_snippet=self._state.current_snippet,
-            task_description=task["description"],
+            task_description=task_base["description"],
             task_id=self._state.current_task_id,
             attempt_number=self._state.step_count,
             previous_feedback=feedback,
             done=done,
+            hint=None,
         )
 
     @property