Final Commit

inference.py

@@ -220,6 +220,131 @@ def run_episode(client: Optional[OpenAI], task_id: str, episode_num: int) -> flo
     return task_score
 
 
+def run_all_tasks() -> Dict[str, float]:
+    """
+    Run all three tasks and return deterministic scores.
+
+    This is used by the FastAPI server to show live demo results on the Space.
+    """
+
+    # Prefer local in-process execution when running inside the server (no ENV_URL needed).
+    try:
+        from acre.tasks.task_registry import TaskRegistry
+        from openenv_interface import OpenEnvRefactorEnv
+    except Exception:
+        TaskRegistry = None  # type: ignore[assignment]
+        OpenEnvRefactorEnv = None  # type: ignore[assignment]
+
+    registry = TaskRegistry() if TaskRegistry is not None else None
+    env = OpenEnvRefactorEnv(registry=registry) if OpenEnvRefactorEnv is not None else None
+
+    def _choose_action_name(code: str, task_id: str) -> int:
+        # Reuse the same heuristic logic (deterministic).
+        has_generic = re.search(r"\b(x|tmp|i)\b", code) is not None
+        has_if_false = re.search(r"\bif\s+False\b", code) is not None
+        has_if_true = re.search(r"\bif\s+True\b", code) is not None
+        has_append_loop = ".append(" in code and "for " in code
+        has_double_not = "not not" in code
+        has_add_call = "add(" in code
+
+        if task_id == "rename_variables":
+            if has_generic:
+                return 0
+            if has_if_false or "unused" in code:
+                return 1
+            if has_append_loop:
+                return 2
+            if has_if_true or has_double_not:
+                return 3
+            return 4
+
+        if task_id == "remove_dead_code":
+            if has_if_false or "unused" in code:
+                return 1
+            if has_append_loop:
+                return 2
+            if has_if_true or has_double_not:
+                return 3
+            if has_generic:
+                return 0
+            return 4
+
+        if has_generic:
+            return 0
+        if has_append_loop:
+            return 2
+        if has_if_false or has_if_true or has_double_not:
+            return 3
+        if has_add_call:
+            return 4
+        return 1
+
+    # Map tasks → nice names for demo output.
+    task_plan = [
+        ("easy_task", "rename_variables"),
+        ("medium_task", "remove_dead_code"),
+        ("hard_task", "full_refactor"),
+    ]
+
+    results: Dict[str, float] = {"easy": 0.0, "medium": 0.0, "hard": 0.0, "final": 0.0}
+    scores: List[float] = []
+
+    # If we have a local env, use it. Otherwise fall back to HTTP (requires ENV_URL).
+    if env is None or registry is None:
+        if not ENV_URL:
+            return results
+        # Use existing HTTP-driven path.
+        client: Optional[OpenAI] = None
+        for label, task_id in task_plan:
+            print(f"START {label}", flush=True)
+            reset_env(task_id)
+            for _ in range(5):
+                state = get_state()
+                action = _choose_action_name(str(state.get("current_code", "")), task_id)
+                action_name = ACTION_MEANINGS.get(int(action), "unknown")
+                print(f"STEP {action_name}", flush=True)
+                step_env(action)
+            final_state = get_state()
+            score = float(grade(task_id, final_state.get("current_code", "")))
+            print(f"END score: {score:.2f}", flush=True)
+            scores.append(score)
+            if task_id == "rename_variables":
+                results["easy"] = score
+            elif task_id == "remove_dead_code":
+                results["medium"] = score
+            else:
+                results["hard"] = score
+
+        results["final"] = float(sum(scores) / len(scores)) if scores else 0.0
+        return results
+
+    # Local in-process execution (fast + no network recursion).
+    for label, task_id in task_plan:
+        print(f"START {label}", flush=True)
+        env.reset(seed=0, task_id=task_id)
+        for _ in range(5):
+            st = env.state()
+            code = str(st.current_code)
+            action = int(_choose_action_name(code, task_id))
+            action_name = env.action_meanings.get(action, "unknown")
+            print(f"STEP {action_name}", flush=True)
+            env.step(action)
+        st = env.state()
+        task = registry.get_task(task_id)
+        score = float(task.grade_against_expected(st.current_code)) if task is not None else 0.0
+        print(f"END score: {score:.2f}", flush=True)
+        scores.append(score)
+        if task_id == "rename_variables":
+            results["easy"] = score
+        elif task_id == "remove_dead_code":
+            results["medium"] = score
+        else:
+            results["hard"] = score
+
+    results["final"] = float(sum(scores) / len(scores)) if scores else 0.0
+    return results
+
+
 def main() -> None:
     if not ENV_URL:
         raise SystemExit("ENV_URL is required. Example: ENV_URL=http://localhost:7860")

server.py

@@ -22,7 +22,7 @@ import uvicorn
 import numpy as np
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse
+from fastapi.responses import HTMLResponse, JSONResponse
 from openai import OpenAI
 
 PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
@@ -468,10 +468,25 @@ def _demo_html() -> str:
 # Routes
 # ---------------------------------------------------------------------------
 
-@app.get("/", response_model=HealthResponse)
-def health() -> HealthResponse:
-    """Health check — OpenEnv pings this URL to verify the Space is live."""
-    return HealthResponse(status="ok", env="ACRE", version="1.0.0")
+@app.get("/")
+def root() -> JSONResponse:
+    """
+    Live demo root endpoint.
+
+    Hugging Face Spaces typically render the response from `/` in the preview.
+    We run a deterministic demo episode over all tasks and return the results.
+    """
+    from inference import run_all_tasks
+
+    results = run_all_tasks()
+    payload = {
+        "status": "ok",
+        "env": "ACRE",
+        "version": "1.0.0",
+        "message": "ACRE running successfully",
+        "results": results,
+    }
+    return JSONResponse(content=payload)
 
 
 @app.get("/health", response_model=CompatibilityHealthResponse)
@@ -480,7 +495,15 @@ def health_compat() -> CompatibilityHealthResponse:
     return CompatibilityHealthResponse(status="healthy", service="acre-env")
 
 
-@app.get("/demo", response_class=HTMLResponse)
+@app.get("/demo")
+def demo() -> JSONResponse:
+    """Run all tasks and return JSON results."""
+    from inference import run_all_tasks
+
+    return JSONResponse(content={"results": run_all_tasks()})
+
+
+@app.get("/ui", response_class=HTMLResponse)
 def demo_ui() -> HTMLResponse:
     """Simple UI to compare original and optimized code side-by-side."""
     return HTMLResponse(content=_demo_html())