Upload folder using huggingface_hub

Dockerfile

@@ -56,4 +56,8 @@ HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
 
 # Start the server on 7860 with proxy support
 # 'proxy_headers' is vital for HF reverse proxies to handle WebSockets correctly
-CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "7860", "--proxy-headers", "--forwarded-allow-ips", "*"]
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "7860", "--proxy-headers", "--forwarded-allow-ips", "*"]
+
+WORKDIR /app/env
+COPY . .
+# This places QUESTIONS.json at /app/env/server/QUESTIONS.json

server/app.py

@@ -1,32 +1,5 @@
 # Copyright (c) Meta Platforms, Inc. and affiliates.
 # All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-FastAPI application for the Lint Coding Agent Environment.
-
-This module creates an HTTP server that exposes the LintCodingAgentEnvironment
-over HTTP and WebSocket endpoints, compatible with EnvClient.
-
-Endpoints:
-    - POST /reset: Reset the environment
-    - POST /step: Execute an action
-    - GET /state: Get current environment state
-    - GET /schema: Get action/observation schemas
-    - WS /ws: WebSocket endpoint for persistent sessions
-
-Usage:
-    # Development (with auto-reload):
-    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
-
-    # Production:
-    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
-
-    # Or run directly:
-    python -m server.app
-"""
 
 import sys
 import os
@@ -44,10 +17,11 @@ logging.basicConfig(
 logger = logging.getLogger("ArchitectApp")
 
 # --- ARCHITECT'S PATH INJECTION ---
+# We force the root and server dirs into sys.path to ensure 'models' is found
 current_dir = os.path.dirname(os.path.abspath(__file__))
 project_root = os.path.abspath(os.path.join(current_dir, ".."))
 
-for path in [project_root, current_dir]:
+for path in [project_root, current_dir, os.getcwd()]:
     if path not in sys.path:
         sys.path.insert(0, path)
 
@@ -58,11 +32,12 @@ except ImportError:
     from openenv.core.env_server.http_server import create_app
 
 # --- DOMAIN SPECIFIC IMPORTS ---
+# These are the schemas and logic we verified in previous steps
 from models import LintCodingAgentAction, LintCodingAgentObservation
 from server.lint_coding_agent_environment import LintCodingAgentEnvironment
 
 # --- APP FACTORY ---
-# 1. Create the environment logic app
+# 1. Create the environment logic app (The core OpenEnv engine)
 base_app = create_app(
     LintCodingAgentEnvironment,
     LintCodingAgentAction,
@@ -70,19 +45,23 @@ base_app = create_app(
 )
 
 # 2. Create the Main Wrapper App
-app = FastAPI(title="AnonAjay Architect API")
+# redirect_slashes=False is CRITICAL to prevent 307 Redirect loops on HF
+app = FastAPI(
+    title="AnonAjay Architect API",
+    redirect_slashes=False
+)
 
 # --- DEBUG MIDDLEWARE ---
-# This will print every single request coming from Hugging Face to your logs
+# Real-time telemetry for every request hitting the Space
 @app.middleware("http")
 async def debug_logging(request: Request, call_next):
     logger.info(f"📡 Request: {request.method} {request.url.path}")
     response = await call_next(request)
-    logger.info(f"✅ Response Status: {response.status_code}")
+    logger.info(f"✅ Outcome: {response.status_code}")
     return response
 
 # --- MOUNTING (The /v1 Fix) ---
-# This ensures that /v1/reset and /v1/ws are explicitly mapped
+# This ensures that /v1/reset and /v1/ws are mapped to the core engine
 app.mount("/v1", base_app)
 
 # --- CORS SECURITY ---
@@ -96,7 +75,20 @@ app.add_middleware(
 
 @app.get("/health")
 def health_check():
-    return {"status": "online", "message": "Lead Architect Server is Active"}
+    """Simple health probe for Docker and HF status checks."""
+    return {"status": "online", "message": "Lead Architect Server is Active", "port": 7860}
+
+# Catch-all for the root to prevent confusing 404s in the browser
+@app.get("/")
+def root_info():
+    return {
+        "message": "Lint Coding Agent API is Running",
+        "endpoints": {
+            "docs": "/v1/docs",
+            "health": "/health",
+            "api_root": "/v1"
+        }
+    }
 
 def main():
     """
@@ -109,8 +101,9 @@ def main():
     args = parser.parse_args()
     
     logger.info(f"🚀 OpenEnv Sandbox Starting on {args.host}:{args.port}")
-    logger.info(f"📍 Mount Point: /v1 mapped to OpenEnv Core")
+    logger.info(f"📍 Geometry: /v1 mapped to OpenEnv Core")
     
+    # proxy_headers + forwarded_allow_ips are vital for HF reverse proxy support
     uvicorn.run(
         app, 
         host=args.host, 

server/lint_coding_agent_environment.py

@@ -1,8 +1,5 @@
 # Copyright (c) Meta Platforms, Inc. and affiliates.
 # All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
 
 import json
 import os
@@ -15,7 +12,7 @@ from typing import Tuple, Dict, Any, List
 from openenv.core.env_server.interfaces import Environment
 from openenv.core.env_server.types import State
 
-# Setup Logging
+# Lead Architect Telemetry
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("ArchitectEnvironment")
 
@@ -28,7 +25,7 @@ except ImportError:
 class LintCodingAgentEnvironment(Environment):
     """
     Advanced Repository Sandbox. 
-    Fixed for Docker/Hugging Face pathing with robust resource discovery.
+    Enhanced with Deep Path Discovery to eliminate Docker 'File Not Found' errors.
     """
     SUPPORTS_CONCURRENT_SESSIONS: bool = True
 
@@ -38,61 +35,65 @@ class LintCodingAgentEnvironment(Environment):
         self.failed_queue = []
         self.vfs: Dict[str, str] = {}
         
-        # --- ROBUST PATH DISCOVERY ---
-        # 1. Try directory relative to this file
-        current_file_dir = os.path.dirname(os.path.abspath(__file__))
-        
-        # Candidate paths for QUESTIONS.json
-        candidates = [
-            os.path.join(current_file_dir, "QUESTIONS.json"),
-            os.path.join(os.getcwd(), "server", "QUESTIONS.json"),
-            os.path.join(os.getcwd(), "QUESTIONS.json"),
-            "/app/server/QUESTIONS.json"
-        ]
-        
-        json_path = None
-        for path in candidates:
-            if os.path.exists(path):
-                json_path = path
-                self.templates_base = os.path.join(os.path.dirname(path), "templates")
-                break
+        # --- ELITE DEEP RESOURCE DISCOVERY ---
+        # We don't guess paths; we find them.
+        json_path = self._discover_resource("QUESTIONS.json")
         
         if json_path:
-            logger.info(f"🏗️ Environment Resources Found: {json_path}")
+            logger.info(f"🎯 Resource Secured: {json_path}")
+            self.templates_base = os.path.join(os.path.dirname(json_path), "templates")
             try:
                 with open(json_path, "r") as f:
                     self.curriculum = json.load(f)
                 self.all_levels = sorted(list(self.curriculum.keys()), key=int)
-                logger.info(f"📚 Curriculum Loaded: {len(self.all_levels)} levels.")
+                logger.info(f"📚 Curriculum Validated: {len(self.all_levels)} levels loaded.")
             except Exception as e:
-                logger.error(f"❌ Error reading QUESTIONS.json: {e}")
-                self._set_fallback_curriculum()
+                logger.error(f"❌ Read Failure on QUESTIONS.json: {e}")
+                self._apply_fallback()
         else:
-            logger.error(f"❌ CRITICAL: QUESTIONS.json not found in any candidate path: {candidates}")
-            self._set_fallback_curriculum()
+            logger.error("❌ CRITICAL: Manifest QUESTIONS.json missing from all search roots.")
+            self._apply_fallback()
         
         self.max_levels = int(self.all_levels[-1]) if self.all_levels else 1
 
-    def _set_fallback_curriculum(self):
+    def _discover_resource(self, filename: str) -> str:
+        """Scans standard Docker and local roots to locate critical engine files."""
+        # Order of search: Current Dir -> Env Root -> App Root -> Explicit Docker Path
+        roots = [
+            os.path.dirname(os.path.abspath(__file__)),
+            os.getcwd(),
+            "/app/env/server",
+            "/app/env",
+            "/app"
+        ]
+        
+        for root in roots:
+            candidate = os.path.join(root, filename)
+            if os.path.exists(candidate):
+                return candidate
+        return None
+
+    def _apply_fallback(self):
+        """Prevents server crash by providing a baseline Level 1."""
         self.curriculum = {"1": {"lang": "Python", "task": "Fallback: Init", "template_dir": "level_1", "ans": "print"}}
         self.all_levels = ["1"]
-        self.templates_base = os.path.join(os.path.dirname(os.path.abspath(__file__)), "templates")
+        self.templates_base = os.path.join(os.getcwd(), "templates")
 
     def reset(self) -> LintCodingAgentObservation:
         """Full state reset for Phase 2 scoring."""
-        logger.info("🔄 Resetting Environment State...")
+        logger.info("🔄 Resetting Sandbox State...")
         self._state = State(episode_id=str(uuid4()), step_count=0)
         self.level = 1
         self.failed_queue = []
         return self._load_template_state("Environment Reset: 15-Level Sprint Initialized.")
 
     def _load_template_state(self, msg: str) -> LintCodingAgentObservation:
-        """Loads physical files into the VFS with debug tracking."""
+        """Loads physical files into the VFS with rigorous logging."""
         task_data = self.curriculum.get(str(self.level), {})
         template_dir_name = task_data.get("template_dir", f"level_{self.level}")
         template_path = os.path.join(self.templates_base, template_dir_name)
         
-        logger.info(f"📂 Loading Template for Level {self.level}: {template_path}")
+        logger.info(f"📂 VFS Switch | Level {self.level} | Root: {template_path}")
         
         self.vfs = {}
         if os.path.exists(template_path):
@@ -103,19 +104,19 @@ class LintCodingAgentEnvironment(Environment):
                     try:
                         with open(full_p, 'r', encoding='utf-8') as file:
                             self.vfs[rel_p] = file.read()
-                        logger.info(f"  📄 VFS Mounted: {rel_p}")
+                        logger.info(f"  📄 File Mounted: {rel_p}")
                     except Exception as e:
-                        logger.error(f"  ⚠️ VFS Read Error {rel_p}: {e}")
+                        logger.error(f"  ⚠️ Read Warning {rel_p}: {e}")
         else:
-            logger.error(f"❌ CRITICAL: Level path missing: {template_path}")
+            logger.error(f"❌ Directory Missing: {template_path}")
             
         return self._get_observation(msg, 0.0, False)
 
     def _check_hijacking(self, action: LintCodingAgentAction) -> Tuple[bool, str, float]:
-        """Anti-adversarial monitor to prevent agent shortcuts."""
+        """Enforces architectural integrity."""
         new_code = action.code_solution or ""
         if len(new_code.strip()) < 10:
-             return True, "HIJACK: Solution rejected for insufficient depth.", -2.0
+             return True, "HIJACK: Solution rejected (insufficient depth).", -2.0
         
         code_only = re.sub(r'#.*', '', new_code).strip()
         if len(code_only) < 5:
@@ -124,14 +125,14 @@ class LintCodingAgentEnvironment(Environment):
         return False, "", 0.0
 
     def _is_syntactically_valid(self, code: str, lang: str) -> Tuple[bool, str]:
-        """Verifies solution validity based on language type."""
+        """Structural validation using AST."""
         if lang.lower() == "python":
             try:
                 ast.parse(code)
                 return True, "Syntax Valid"
             except SyntaxError as e:
-                return False, f"SyntaxError: {e.msg} (Line {e.lineno})"
-        return (True, "Non-Python/No-Verify") if len(code) > 5 else (False, "Empty Solution")
+                return False, f"SyntaxError: {e.msg}"
+        return (True, "Non-Python") if len(code) > 5 else (False, "Empty")
 
     def step(self, action: LintCodingAgentAction) -> LintCodingAgentObservation:
         self._state.step_count += 1
@@ -139,35 +140,33 @@ class LintCodingAgentEnvironment(Environment):
         
         logger.info(f"👣 STEP {self._state.step_count} | Level: {self.level}")
 
-        # 1. Monitoring
+        # 1. Integrity Check
         is_hijacked, hijack_msg, penalty = self._check_hijacking(action)
         if is_hijacked:
             logger.warning(f"🚫 {hijack_msg}")
             return self._get_observation(hijack_msg, penalty, False)
 
-        # 2. Execution & Verification
+        # 2. Evaluation Logic
         syntax_ok, error_msg = self._is_syntactically_valid(action.code_solution, task_data["lang"])
         
         if not syntax_ok:
             reward = -0.2
             feedback = f"Transition Failed: {error_msg}"
-            logger.info(f"❌ Syntax Invalid: {error_msg}")
         else:
+            # Check logic against manifest 'ans'
             logic_ok = task_data["ans"].lower() in action.code_solution.lower()
             
             if logic_ok:
                 reward = 1.0
                 feedback = f"Level {self.level} Success."
-                logger.info(f"✅ Success! Solution matches logic check.")
+                logger.info("✅ Verification Passed.")
                 self.level += 1
             else:
                 reward = 0.1
                 feedback = f"Syntax OK | Logic Missing: {task_data['task']}"
-                logger.info(f"⚠️ Logic Mismatch.")
                 if str(self.level) not in self.failed_queue:
                     self.failed_queue.append(str(self.level))
 
-        # 3. Handle Progression
         done = self.level > self.max_levels
         
         if not done and reward > 0.8:
@@ -182,16 +181,12 @@ class LintCodingAgentEnvironment(Environment):
         return LintCodingAgentObservation(
             level=self.level,
             language=task_data["lang"],
-            problem_statement=f"{feedback} | Current Task: {task_data['task']}",
+            problem_statement=f"{feedback} | Task: {task_data['task']}",
             code_context=json.dumps(self.vfs), 
             last_test_results=feedback,
             reward=reward,
             done=done,
-            metadata={
-                "step": self._state.step_count,
-                "vfs_files": list(self.vfs.keys()),
-                "total_levels": self.max_levels
-            }
+            metadata={"step": self._state.step_count, "vfs_files": list(self.vfs.keys())}
         )
 
     @property