Update app.py

app.py

@@ -28,6 +28,7 @@ PYTHON_MODEL = "Nxcode-CQ-7B-orpo"
 OTHER_MODEL = "Qwen/Qwen2.5-Coder-32B-Instruct"
 FALLBACK_MODELS = [
     "Qwen/Qwen2.5-Coder-32B-Instruct",
+    "Nxcode-CQ-7B-orpo",
     "OpenCodeInterpreter-DS-33B"
 ]
 
@@ -167,6 +168,8 @@ def call_model(client: InferenceClient, system: str, user: str, is_python: bool,
     primary_model = PYTHON_MODEL if is_python else OTHER_MODEL
     models_to_try = [primary_model] + FALLBACK_MODELS
     
+    logging.info(f"Calling model for {'Python' if is_python else 'Other'} project. Primary: {primary_model}")
+    
     messages = [{"role": "system", "content": system}, {"role": "user", "content": user}]
     
     last_exception = None
@@ -232,33 +235,66 @@ def validate_files_dict(files: Dict[str, str]) -> bool:
 def parse_meta(text: str) -> Optional[Dict[str, Any]]:
     """Parses model output to extract code files, trying structured JSON first, then falling back to heuristics."""
     # Strict JSON/META block parsing
-    for pattern in [r"```json\s*(.*?)```", r"```meta\s*(.*?)```"]:
+    for pattern in [r"```json\s*(.*?)```", r"```meta\s*(.*?)```", r"```META\s*(.*?)```"]:
         match = re.search(pattern, text, re.DOTALL | re.IGNORECASE)
         if match:
             try:
                 content = match.group(1).strip()
                 parsed = json.loads(content)
                 if "files" in parsed and validate_files_dict(parsed["files"]):
+                    logging.info(f"Successfully parsed META JSON with {len(parsed['files'])} files")
                     return parsed
-            except (json.JSONDecodeError, TypeError):
+            except (json.JSONDecodeError, TypeError) as e:
+                logging.warning(f"JSON parse failed: {e}")
                 continue
     
     # Fallback to heuristic parsing of code blocks
     files = {}
+    
+    # Try to find filename markers before code blocks
+    # Patterns like: # File: main.py or ## main.py or **main.py**
+    filename_patterns = [
+        r'#\s*[Ff]ile:\s*([\w/._-]+\.[\w]+)',
+        r'##\s*([\w/._-]+\.[\w]+)',
+        r'\*\*\s*([\w/._-]+\.[\w]+)\s*\*\*'
+    ]
+    
+    all_filenames = []
+    for pattern in filename_patterns:
+        all_filenames.extend(re.findall(pattern, text))
+    
     code_blocks = re.findall(r"```(?:\w+)?\s*([\s\S]*?)```", text, re.DOTALL)
+    
     if not code_blocks:
+        logging.warning("No code blocks found in model response")
         return None
 
-    # Try to find filenames from comments or preceding lines
-    # This is a simplified heuristic; more advanced logic could be added
-    potential_filenames = re.findall(r'#\s*File:\s*([\w/._-]+)', text)
+    # Match filenames with code blocks
     for i, block in enumerate(code_blocks):
-        filename = potential_filenames[i] if i < len(potential_filenames) else f"file_{i+1}.py"
-        files[filename] = block.strip()
+        block_content = block.strip()
+        if not block_content:
+            continue
+            
+        if i < len(all_filenames):
+            filename = all_filenames[i]
+        else:
+            # Guess filename based on content
+            if "def test_" in block_content or "import pytest" in block_content:
+                filename = f"test_main.py"
+            elif "requirements" in text.lower() and i == 0:
+                filename = "requirements.txt"
+            elif "# README" in block_content or "## " in block_content[:100]:
+                filename = "README.md"
+            else:
+                filename = f"main.py" if i == 0 else f"file_{i}.py"
+        
+        files[filename] = block_content
 
-    if validate_files_dict(files):
+    if validate_files_dict(files) and files:
+        logging.info(f"Heuristic parsing extracted {len(files)} files: {list(files.keys())}")
         return {"files": files, "changelog": "Extracted files via heuristic parsing."}
-        
+    
+    logging.error("Failed to extract any valid files from model response")
     return None
 
 # ---------- Enhanced evaluators ----------
@@ -468,11 +504,16 @@ Return the perfected code in META format."""
             response = call_model(self.client, system, prompt, self.is_python, **self.settings)
 
             if "<<ERROR" in response:
+                logging.error(f"Model returned error: {response[:200]}")
                 return {"success": False, "warning": "Model error - keeping previous code"}
 
             meta = parse_meta(response)
             if not meta or not meta.get("files"):
-                return {"success": False, "warning": "Parse failed - keeping previous code"}
+                logging.error(f"Parse failed. Response preview: {response[:500]}")
+                # Save failed response for debugging
+                with open(f"/tmp/failed_response_{iteration}.txt", "w") as f:
+                    f.write(response)
+                return {"success": False, "warning": f"Parse failed - see /tmp/failed_response_{iteration}.txt"}
 
             files = meta["files"]
             write_files(workdir, files)
@@ -508,17 +549,22 @@ Return the perfected code in META format."""
             if self.stop_flag.exists():
                 try:
                     self.stop_flag.unlink()
-                except OSError: pass
-                yield self.format_output("Stopped by user", iteration, max_iterations)
+                    logging.info("Stop flag detected - stopping generation")
+                except OSError:
+                    pass
+                yield self.format_output("⛔ Stopped by user", iteration, max_iterations)
                 break
             
-            yield self.format_output(f"Iteration {iteration}/{max_iterations} running...", iteration, max_iterations)
+            yield self.format_output(f"🔄 Iteration {iteration}/{max_iterations} running...", iteration, max_iterations)
             
             result = self.perform_iteration(iteration)
             
             if not result.get("success"):
-                logging.warning(result.get("warning", "Unknown iteration error"))
-                time.sleep(1) # Pause before retrying or ending
+                warning_msg = result.get("warning", "Unknown iteration error")
+                logging.warning(f"Iteration {iteration} failed: {warning_msg}")
+                # CRITICAL: Still yield output so UI updates and shows the previous best code
+                yield self.format_output(f"⚠️ Iteration {iteration} failed: {warning_msg}", iteration, max_iterations)
+                time.sleep(2)  # Give more time before retry
                 iteration += 1
                 continue
 
@@ -539,6 +585,10 @@ Return the perfected code in META format."""
                 self.best_zip = result.get("zip")
                 self.best_review = result.get("review", "")
                 self.best_readme = result.get("readme", "")
+                logging.info(f"New best score: {score}/100")
+            else:
+                # Even if score didn't improve, still update current_files for next iteration
+                logging.info(f"Score {score}/100 - keeping best: {self.best_score}/100")
             
             if result.get("workdir") and result.get("workdir") != self.best_workspace:
                 self.cleanup_workdir(Path(result["workdir"]))
@@ -669,9 +719,15 @@ def create_ui():
 
         def set_stop(controller_state_val):
             if controller_state_val and (stop_path_str := controller_state_val.get("stop_flag_path")):
-                Path(stop_path_str).touch()
-                return "Stop signal sent..."
-            return "Could not stop: no active process found."
+                stop_path = Path(stop_path_str)
+                try:
+                    stop_path.touch()
+                    logging.info(f"Stop flag created at {stop_path}")
+                    return "⛔ Stop signal sent! Will stop after current iteration completes..."
+                except Exception as e:
+                    logging.error(f"Failed to create stop flag: {e}")
+                    return f"❌ Failed to stop: {e}"
+            return "❌ Could not stop: No active process found. Start generation first."
 
         outputs = [
             run_log, model_display, progress_display, metrics_html, eval_json,