eas inferenece and added hard, mdeium task

inference.py

@@ -0,0 +1,151 @@
+# inference.py
+import asyncio
+import json
+import os
+import textwrap
+from typing import List, Optional
+
+from openai import OpenAI
+from dotenv import load_dotenv # <-- Add this
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Our environment directly for local testing
+from src.jira_to_code.server.env import JiraToCodeEnv
+from src.jira_to_code.models import JiraCodeAction
+
+# Read from env (with fallbacks just in case)
+API_BASE_URL = os.getenv("API_BASE_URL", "http://localhost:11434/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "qwen3.5:2b")
+HF_TOKEN = os.getenv("HF_TOKEN", "dummy")
+
+TASK_NAME = "easy-bug-fix"
+BENCHMARK = "jira-to-code"
+MAX_STEPS = 10
+SUCCESS_SCORE_THRESHOLD = 1.0
+
+SYSTEM_PROMPT = textwrap.dedent(
+    """
+    You are an expert software engineer resolving Jira tickets.
+    You will receive the objective, the current file tree, and output from actions.
+    
+    You MUST respond with ONLY a valid JSON object representing your next action. 
+    Do not include markdown blocks, explanations, or any other text.
+    
+    Valid action_types: "read_file", "write_file", "run_tests", "submit"
+    
+    JSON Schema:
+    {
+      "action_type": "string",
+      "file_path": "string or null",
+      "content": "string or null"
+    }
+    
+    Example 1: {"action_type": "read_file", "file_path": "calculator.py", "content": null}
+    Example 2: {"action_type": "write_file", "file_path": "calculator.py", "content": "def add(a, b):\n    return a + b"}
+    Example 3: {"action_type": "run_tests", "file_path": null, "content": null}
+    Example 4: {"action_type": "submit", "file_path": null, "content": null}
+    """
+).strip()
+
+# --- MANDATORY LOGGING FUNCTIONS ---
+def log_start(task: str, env: str, model: str) -> None:
+    print(f"[START] task={task} env={env} model={model}", flush=True)
+
+def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
+    error_val = error if error else "null"
+    done_val = str(done).lower()
+    print(f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}", flush=True)
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}", flush=True)
+
+# --- AGENT LOGIC ---
+def build_user_prompt(step: int, obs, last_reward: float) -> str:
+    return textwrap.dedent(
+        f"""
+        Step: {step}
+        Ticket: {obs.jira_ticket}
+        File Tree: {obs.file_tree}
+        Last Read/Write Content: {obs.current_file_content or 'None'}
+        Test Output: {obs.test_output or 'None'}
+        Error: {obs.error or 'None'}
+        Last Reward: {last_reward}
+        
+        Determine your next action and return ONLY the JSON.
+        """
+    ).strip()
+
+def get_action_from_llm(client: OpenAI, step: int, obs, last_reward: float) -> JiraCodeAction:
+    user_prompt = build_user_prompt(step, obs, last_reward)
+    try:
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=0.1, # Keep it low for coding/JSON accuracy
+            max_tokens=500,
+        )
+        raw_text = (completion.choices[0].message.content or "").strip()
+        
+        # Clean up in case the model wraps JSON in markdown
+        if raw_text.startswith("```json"):
+            raw_text = raw_text.replace("```json", "", 1).replace("```", "", 1).strip()
+            
+        action_dict = json.loads(raw_text)
+        return JiraCodeAction(**action_dict), raw_text
+        
+    except Exception as exc:
+        # Fallback action if parsing fails so the environment doesn't crash
+        error_msg = f"LLM Parsing Error: {exc}"
+        return JiraCodeAction(action_type="read_file", file_path="calculator.py"), error_msg
+
+# --- MAIN LOOP ---
+async def main() -> None:
+    client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+    env = JiraToCodeEnv()
+
+    rewards: List[float] = []
+    steps_taken = 0
+    score = 0.0
+    success = False
+
+    log_start(task=TASK_NAME, env=BENCHMARK, model=MODEL_NAME)
+
+    try:
+        obs = await env.reset()
+        last_reward = 0.0
+
+        for step in range(1, MAX_STEPS + 1):
+            action, raw_action_str = get_action_from_llm(client, step, obs, last_reward)
+            
+            # Escape newlines for single-line logging
+            safe_action_str = raw_action_str.replace('\n', '\\n').replace('\r', '')
+
+            # Take step in environment
+            obs, reward, done, _ = await env.step(action)
+            error = obs.error
+
+            rewards.append(reward)
+            steps_taken = step
+            last_reward = reward
+
+            log_step(step=step, action=safe_action_str, reward=reward, done=done, error=error)
+
+            if done:
+                break
+
+        # Calculate final score (clamp between 0 and 1)
+        score = min(max(sum(rewards), 0.0), 1.0)
+        success = score >= SUCCESS_SCORE_THRESHOLD
+
+    finally:
+        await env.close()
+        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/jira_to_code/server/env.py

@@ -1,41 +1,138 @@
 # src/jira_to_code/server/env.py
+import os
+import shutil
+import tempfile
+import subprocess
+from pathlib import Path
 from typing import Tuple, Dict, Any
+
 from openenv.core.env_server import Environment, State
 from src.jira_to_code.models import JiraCodeAction, JiraCodeObservation
 
 class JiraToCodeEnv(Environment):
+    TASKS = {
+        "easy": {
+            "dir": "src/jira_to_code/tasks/easy",
+            "ticket": "TICKET-101: Fix the off-by-one bug in calculator.add() function. It should correctly sum two numbers."
+        },
+        "medium": {
+            "dir": "src/jira_to_code/tasks/medium",
+            "ticket": "TICKET-201: Implement format_user_data in formatter.py. It should format dictionary data to 'LAST_NAME, First_name (Age: X)'. Handle missing age by defaulting to 'Unknown'."
+        },
+        "hard": {
+            "dir": "src/jira_to_code/tasks/hard",
+            "ticket": "TICKET-301: Implement an LRUCache class in lru_cache.py with put() and get() methods. O(1) time complexity expected. Evict least recently used when capacity is reached."
+        }
+    }
+
     def __init__(self):
         super().__init__()
-        self.current_task = None
-        self.workspace_dir = None
         self.step_count = 0
+        self.workspace_dir = None
         
+        # Determine which task to run based on environment variable (defaults to easy)
+        self.task_level = os.getenv("JIRA_TASK_LEVEL", "easy").lower()
+        if self.task_level not in self.TASKS:
+            self.task_level = "easy"
+            
+        self.task_source_dir = Path(self.TASKS[self.task_level]["dir"]).resolve()
+        self.jira_ticket = self.TASKS[self.task_level]["ticket"]
+
+    def _get_file_tree(self) -> list[str]:
+        if not self.workspace_dir:
+            return []
+        tree = []
+        for root, _, files in os.walk(self.workspace_dir):
+            for file in files:
+                if "__pycache__" in root or file.endswith(".pyc"):
+                    continue
+                rel_path = Path(root) / file
+                tree.append(str(rel_path.relative_to(self.workspace_dir)))
+        return tree
+
     async def reset(self) -> JiraCodeObservation:
-        """Initialize a new episode, return initial observation."""
         self.step_count = 0
+        if self.workspace_dir and Path(self.workspace_dir).exists():
+            shutil.rmtree(self.workspace_dir)
+            
+        self.workspace_dir = tempfile.mkdtemp(prefix=f"jira_env_{self.task_level}_")
+        
+        if self.task_source_dir.exists():
+            shutil.copytree(self.task_source_dir, self.workspace_dir, dirs_exist_ok=True)
+        else:
+            print(f"Warning: Task directory {self.task_source_dir} not found!")
+            
         return JiraCodeObservation(
-            jira_ticket="TICKET-123: Fix off-by-one error in calculator.py",
-            file_tree=["calculator.py", "tests/test_calculator.py"],
-            current_file_content=None,
-            test_output=None,
-            error=None
+            jira_ticket=self.jira_ticket,
+            file_tree=self._get_file_tree()
         )
 
     async def step(self, action: JiraCodeAction) -> Tuple[JiraCodeObservation, float, bool, Dict[str, Any]]:
-        """Execute action, return resulting Observation, reward, done, info."""
         self.step_count += 1
-        
+        reward = 0.0
+        done = False
+        current_file_content = None
+        test_output = None
+        error = None
+
+        workspace_path = Path(self.workspace_dir).resolve()
+
+        try:
+            if action.action_type in ["read_file", "write_file"]:
+                if not action.file_path:
+                    error = "file_path must be provided for read/write actions."
+                else:
+                    target_path = (workspace_path / action.file_path).resolve()
+                    if not target_path.is_relative_to(workspace_path):
+                        error = "Access denied: cannot access files outside workspace."
+                    elif action.action_type == "read_file":
+                        if target_path.exists():
+                            current_file_content = target_path.read_text()
+                        else:
+                            error = f"File not found: {action.file_path}"
+                    elif action.action_type == "write_file":
+                        if action.content is None:
+                            error = "content must be provided for write_file action."
+                        else:
+                            target_path.parent.mkdir(parents=True, exist_ok=True)
+                            target_path.write_text(action.content)
+                            current_file_content = action.content
+
+            elif action.action_type == "run_tests":
+                result = subprocess.run(["pytest"], cwd=self.workspace_dir, capture_output=True, text=True)
+                test_output = result.stdout + "\n" + result.stderr
+                if result.returncode == 0:
+                    reward = 0.5 
+                elif result.returncode == 1:
+                    reward = 0.1  
+                else:
+                    reward = -0.1 
+
+            elif action.action_type == "submit":
+                result = subprocess.run(["pytest"], cwd=self.workspace_dir, capture_output=True, text=True)
+                test_output = result.stdout + "\n" + result.stderr
+                done = True
+                if result.returncode == 0:
+                    reward = 1.0  
+                else:
+                    reward = 0.0  
+
+        except Exception as e:
+            error = f"System error: {str(e)}"
+            reward = -0.2 
+
         obs = JiraCodeObservation(
-            jira_ticket="TICKET-123: Fix off-by-one error in calculator.py",
-            file_tree=["calculator.py", "tests/test_calculator.py"],
-            current_file_content="def add(a, b):\n    return a + b + 1  # BUG",
-            test_output=None,
-            error=None
+            jira_ticket=self.jira_ticket,
+            file_tree=self._get_file_tree(),
+            current_file_content=current_file_content,
+            test_output=test_output,
+            error=error
         )
-        
-        # Standard format: observation, reward, done, info dict
-        return obs, 0.0, False, {}
+        return obs, reward, done, {}
 
     async def state(self) -> State:
-        """Access episode metadata."""
-        return State(episode_id="test-123", step_count=self.step_count)
+        return State(episode_id=f"jira-{self.task_level}-{self.step_count}", step_count=self.step_count)
+    
+    async def close(self):
+        if self.workspace_dir and Path(self.workspace_dir).exists():
+            shutil.rmtree(self.workspace_dir)

src/jira_to_code/tasks/easy/calculator.py

@@ -0,0 +1,3 @@
+def add(a, b):
+    # BUG: Off by one error
+    return a + b + 1

src/jira_to_code/tasks/easy/tests/test_calculator.py

@@ -0,0 +1,6 @@
+from calculator import add
+
+def test_add():
+    assert add(2, 3) == 5
+    assert add(0, 0) == 0
+    assert add(-1, 1) == 0

src/jira_to_code/tasks/hard/lru_cache.py

@@ -0,0 +1,13 @@
+class LRUCache:
+    def __init__(self, capacity: int):
+        # TODO: Initialize your cache data structures here
+        pass
+
+    def get(self, key: int) -> int:
+        # TODO: Return the value if key exists, otherwise return -1. 
+        # Accessing an item makes it the most recently used.
+        pass
+
+    def put(self, key: int, value: int) -> None:
+        # TODO: Add key-value pair. If capacity is exceeded, evict the least recently used item.
+        pass

src/jira_to_code/tasks/hard/tests/test_cache.py

@@ -0,0 +1,13 @@
+from lru_cache import LRUCache
+
+def test_lru_cache_operations():
+    cache = LRUCache(2)
+    cache.put(1, 1)
+    cache.put(2, 2)
+    assert cache.get(1) == 1       # returns 1
+    cache.put(3, 3)                # evicts key 2
+    assert cache.get(2) == -1      # returns -1 (not found)
+    cache.put(4, 4)                # evicts key 1
+    assert cache.get(1) == -1      # returns -1 (not found)
+    assert cache.get(3) == 3       # returns 3
+    assert cache.get(4) == 4       # returns 4

src/jira_to_code/tasks/medium/formatter.py

@@ -0,0 +1,7 @@
+def format_user_data(user_dict):
+    """
+    Takes a dictionary with 'first_name', 'last_name', and 'age'.
+    Should return a string formatted exactly like: "LAST_NAME, First_name (Age: X)"
+    If 'age' is missing, it should default to "Unknown".
+    """
+    pass # TODO: Implement this function based on the docstring

src/jira_to_code/tasks/medium/tests/test_formatter.py

@@ -0,0 +1,9 @@
+from formatter import format_user_data
+
+def test_format_full_data():
+    data = {"first_name": "john", "last_name": "doe", "age": 30}
+    assert format_user_data(data) == "DOE, John (Age: 30)"
+
+def test_format_missing_age():
+    data = {"first_name": "alice", "last_name": "smith"}
+    assert format_user_data(data) == "SMITH, Alice (Age: Unknown)"