Update app.py

app.py

@@ -4,102 +4,141 @@ import subprocess
 import shutil
 import numpy as np
 from PIL import Image
-import pywasm  # Add this to your requirements.txt
+import pywasm
 
-# 1. Setup Persistent Paths
+# 1. Configuration & Persistent Paths
 SAVE_DIR = "/data"
 EMCC_DIR = os.path.join(SAVE_DIR, "emsdk")
-if not os.path.exists(SAVE_DIR): os.makedirs(SAVE_DIR, exist_ok=True)
+if not os.path.exists(SAVE_DIR):
+    os.makedirs(SAVE_DIR, exist_ok=True)
 
-# Helper to get fresh file lists
 def get_wasm_files():
+    """Helper to list current WASM files in the bucket"""
+    if not os.path.exists(SAVE_DIR): return []
     return [f for f in os.listdir(SAVE_DIR) if f.endswith('.wasm')]
 
-# --- COMPILER LOGIC ---
+# 2. Compiler Logic (The Forge)
 def ensure_compiler():
+    """Checks for Emscripten in the bucket, installs if missing"""
     emcc_path = os.path.join(EMCC_DIR, "upstream/emscripten/emcc")
-    if os.path.exists(emcc_path): return emcc_path
+    if os.path.exists(emcc_path):
+        return emcc_path
     try:
+        print("Installing Emscripten to bucket...")
         subprocess.run(["git", "clone", "https://github.com/emscripten-core/emsdk.git", EMCC_DIR], check=True)
         subprocess.run([os.path.join(EMCC_DIR, "emsdk"), "install", "latest"], check=True)
         subprocess.run([os.path.join(EMCC_DIR, "emsdk"), "activate", "latest"], check=True)
         return emcc_path
-    except Exception as e: return f"Error: {e}"
+    except Exception as e:
+        return f"Error: {str(e)}"
 
 def compile_c(c_code, filename):
-    if not filename: return "❌ Need name."
+    if not filename: return "❌ Error: Please provide a filename."
     emcc_path = ensure_compiler()
     if "Error" in emcc_path: return emcc_path
     
     base = filename.split('.')[0]
-    c_f, out_js, out_wasm = f"/tmp/{base}.c", f"/tmp/{base}.js", f"/tmp/{base}.wasm"
-    with open(c_f, "w") as f: f.write(c_code)
+    c_f = f"/tmp/{base}.c"
+    out_wasm = f"/tmp/{base}.wasm"
+    dest_wasm = os.path.join(SAVE_DIR, f"{base}.wasm")
+    
+    with open(c_f, "w") as f:
+        f.write(c_code)
     
     try:
-        # Exporting functions so they are callable by the runner
-        res = subprocess.run([emcc_path, c_f, "-s", "WASM=1", "-s", "EXPORTED_FUNCTIONS=['_main']", "-o", out_js], capture_output=True, text=True)
-        if res.returncode != 0: return f"❌ {res.stderr}"
-        shutil.move(out_wasm, os.path.join(SAVE_DIR, f"{base}.wasm"))
-        return f"✅ Compiled {base}.wasm"
-    except Exception as e: return f"❌ {e}"
+        # STANDALONE_WASM + --no-entry creates a pure binary module for the Runner
+        res = subprocess.run([
+            emcc_path, c_f, 
+            "-s", "WASM=1", 
+            "-s", "STANDALONE_WASM", 
+            "--no-entry", 
+            "-o", out_wasm
+        ], capture_output=True, text=True, timeout=60)
+        
+        if res.returncode != 0:
+            return f"❌ Compiler Error:\n{res.stderr}"
+        
+        if os.path.exists(out_wasm):
+            shutil.move(out_wasm, dest_wasm)
+            return f"✅ Successfully Forged: {base}.wasm"
+        return "❌ Error: WASM file generation failed."
+    except Exception as e:
+        return f"❌ System Error: {str(e)}"
 
-# --- WASM RUNNER (The New "Execution" Tab) ---
+# 3. Execution Logic (The Runner)
 def run_wasm_func(wasm_file, func_name, args):
-    if not wasm_file: return "Select a file."
+    if not wasm_file: return "❌ Select a WASM file."
     path = os.path.join(SAVE_DIR, wasm_file)
     try:
-        runtime = pywasm.load(path)
-        # Parse comma-separated args: "5, 10" -> [5, 10]
+        # Fixed: Using load_module for modern pywasm versions
+        runtime = pywasm.load_module(path)
+        
+        # Parse comma-separated numbers
         arg_list = [int(x.strip()) for x in args.split(",")] if args else []
-        result = runtime.exec(func_name, arg_list)
-        return f"Result: {result}"
+        
+        # Emscripten prefixes C functions with an underscore
+        try:
+            result = runtime.exec(func_name, arg_list)
+        except:
+            result = runtime.exec(f"_{func_name}", arg_list)
+            
+        return f"Execution Successful!\nResult: {result}"
     except Exception as e:
-        return f"Error running {func_name}: {e}"
+        return f"❌ Runner Error: {str(e)}"
 
-# --- VISUALIZER ---
+# 4. Visualizer Logic
 def render_wasm(wasm_file):
-    if not wasm_file: return None, "Select a file."
-    with open(os.path.join(SAVE_DIR, wasm_file), "rb") as f: data = f.read()
+    if not wasm_file: return None, "❌ Select a file."
+    path = os.path.join(SAVE_DIR, wasm_file)
+    
+    with open(path, "rb") as f:
+        data = f.read()
+    
+    # Map binary to 1080p Grid
     arr = np.frombuffer(data, dtype=np.uint8)
     canvas = np.zeros(1920 * 1080, dtype=np.uint8)
-    canvas[:min(len(arr), 1920*1080)] = arr[:min(len(arr), 1920*1080)]
-    return Image.fromarray(canvas.reshape((1080, 1920)), mode='L'), "Rendered."
+    size = min(len(arr), 1920 * 1080)
+    canvas[:size] = arr[:size]
+    
+    img = Image.fromarray(canvas.reshape((1080, 1920)), mode='L')
+    return img, f"Visualizing {len(data)} bytes of logic."
 
-# --- UI ---
+# 5. Gradio Interface Layout
 with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
-    gr.Markdown("# 🛠️ LCPU: Forge, Run & Visualize")
+    gr.Markdown("# 🛠️ LCPU: Spatial Arithmetic Forge")
     
-    with gr.Tab("1. Forge"):
-        name = gr.Textbox(label="WASM Name", value="math_logic")
-        code = gr.TextArea(label="C Code", value='int add(int a, int b) { return a + b; }', lines=6)
-        comp_btn = gr.Button("🚀 Build")
-        status = gr.Textbox(label="Log")
+    with gr.Tab("1. The Forge (C to WASM)"):
+        with gr.Row():
+            wasm_name = gr.Textbox(label="Output Filename", value="math_logic")
+        c_code_input = gr.TextArea(label="C Code Source", value='int add(int a, int b) {\n    return a + b;\n}', lines=8)
+        compile_btn = gr.Button("🚀 Build Binary", variant="primary")
+        forge_status = gr.Textbox(label="Forge Output")
 
-    with gr.Tab("2. Runner"):
+    with gr.Tab("2. The Runner (Execution)"):
         with gr.Row():
-            run_select = gr.Dropdown(label="Select WASM", choices=get_wasm_files())
+            run_select = gr.Dropdown(label="Select Binary", choices=get_wasm_files())
             refresh_run = gr.Button("🔄", variant="secondary")
-        func_input = gr.Textbox(label="Function Name", value="add")
-        args_input = gr.Textbox(label="Arguments (comma separated)", placeholder="5, 10")
-        run_btn = gr.Button("⚡ Execute WASM")
-        run_out = gr.Textbox(label="Output")
+        f_name = gr.Textbox(label="Function Name", value="add")
+        args_in = gr.Textbox(label="Arguments (e.g. 10, 20)", placeholder="5, 5")
+        run_btn = gr.Button("⚡ Run Logic", variant="primary")
+        run_output = gr.Textbox(label="Output Result")
 
-    with gr.Tab("3. Visualizer"):
+    with gr.Tab("3. The Visualizer (Spatial Canvas)"):
         with gr.Row():
-            vis_select = gr.Dropdown(label="Select WASM", choices=get_wasm_files())
+            vis_select = gr.Dropdown(label="Select Binary", choices=get_wasm_files())
             refresh_vis = gr.Button("🔄", variant="secondary")
-        render_btn = gr.Button("🎨 Render 1080p")
-        img_out = gr.Image()
+        render_btn = gr.Button("🎨 Map to 1080p", variant="primary")
+        canvas_img = gr.Image(label="Logic Texture")
+        vis_status = gr.Textbox(label="Canvas Status")
 
-    # Event Logic
-    comp_btn.click(compile_c, [code, name], status)
+    # Wire up the events
+    compile_btn.click(compile_c, [c_code_input, wasm_name], forge_status)
     
-    # Live Refresh Logic
     refresh_run.click(lambda: gr.Dropdown(choices=get_wasm_files()), outputs=run_select)
     refresh_vis.click(lambda: gr.Dropdown(choices=get_wasm_files()), outputs=vis_select)
     
-    run_btn.click(run_wasm_func, [run_select, func_input, args_input], run_out)
-    render_btn.click(render_wasm, vis_select, [img_out, status])
+    run_btn.click(run_wasm_func, [run_select, f_name, args_in], run_output)
+    render_btn.click(render_wasm, vis_select, [canvas_img, vis_status])
 
 if __name__ == "__main__":
     demo.launch()