Spaces:
Runtime error
Runtime error
| """ | |
| ╔══════════════════════════════════════════════════════════════╗ | |
| ║ WIZARD-VIBE CORE — Sandbox-First Architecture ║ | |
| ║ Single-file core: SSE server + orchestrator + self-heal ║ | |
| ║ Hot-reload watcher + iframe sandbox + A2A agent card ║ | |
| ╚══════════════════════════════════════════════════════════════╝ | |
| Architecture: | |
| core.py ← this file: everything in one module | |
| hot_reload.py ← watchdog-based file watcher for dev mode | |
| static/ ← Liquid Glass UI (minimalist HTML/CSS/JS) | |
| sandbox.sh ← one-command bootstrap script | |
| Dockerfile ← containerized deployment | |
| Protocol: | |
| GET / → Liquid Glass UI | |
| GET /api/health → Health check | |
| POST /api/stream → SSE streaming (AsyncIterator) | |
| POST /api/publish → GitHub + HF Spaces + agent.json | |
| GET /.well-known/agent.json → A2A agent card | |
| GET /api/preview?session_id=X → sandbox iframe content | |
| """ | |
| import asyncio | |
| import json | |
| import os | |
| import re | |
| import sys | |
| import time | |
| import uuid | |
| import base64 | |
| from pathlib import Path | |
| from typing import Dict, List, Optional, Tuple | |
| import aiohttp | |
| from aiohttp import web | |
| # ═══════════════════════════════════════════════════════════════ | |
| # CONFIGURATION | |
| # ═══════════════════════════════════════════════════════════════ | |
| PORT = int(os.environ.get("WIZARD_PORT", 8765)) | |
| STATIC_DIR = Path(__file__).parent / "static" | |
| GENERATED_DIR = Path(__file__).parent / "generated" | |
| GENERATED_DIR.mkdir(parents=True, exist_ok=True) | |
| HOT_RELOAD = os.environ.get("WIZARD_HOT_RELOAD", "0") == "1" | |
| # ═══════════════════════════════════════════════════════════════ | |
| # ORCHESTRATOR — Model Posing Engine | |
| # ═══════════════════════════════════════════════════════════════ | |
| class Orchestrator: | |
| """Routes tasks to optimal models by keyword matching.""" | |
| REGISTRY = { | |
| "vision": "microsoft/Phi-3-vision-128k-instruct", | |
| "logic": "deepseek-ai/DeepSeek-V3-0324", | |
| "code": "Qwen/Qwen3-Coder-30B-A3B-Instruct", | |
| "fallback": "mistralai/Mistral-7B-Instruct-v0.3", | |
| } | |
| KEYWORDS = { | |
| "vision": ["ui","design","css","html","layout","color","animation","svg","interface","visual","style","component","frontend","page","web"], | |
| "logic": ["algorithm","sort","search","optimize","compute","math","reasoning","backend","api","database","schema","query","logic"], | |
| "code": ["code","generate","build","create","app","website","script","function","class","module"], | |
| } | |
| def pose(self, prompt: str) -> Dict: | |
| p = prompt.lower() | |
| scores = {d: sum(1 for kw in self.KEYWORDS[d] if kw in p) for d in self.KEYWORDS} | |
| best = max(scores, key=scores.get) | |
| model = self.REGISTRY.get(best, self.REGISTRY["fallback"]) | |
| return {"model": model, "domain": best, "score": scores[best]} | |
| def generate(self, prompt: str): | |
| """Generator yielding code chunks — simulates model streaming.""" | |
| p = prompt.lower() | |
| if "game" in p: | |
| yield from self._game() | |
| elif "api" in p or "backend" in p or "server" in p: | |
| yield from self._api() | |
| elif "component" in p or "react" in p or "vue" in p: | |
| yield from self._component() | |
| else: | |
| yield from self._landing_page(prompt) | |
| def _landing_page(self, prompt: str): | |
| title = "Wizard-Vibe" | |
| for w in ["portfolio","startup","saas","agency","product"]: | |
| if w in prompt.lower(): title = f"{w.title()} — Wizard-Vibe"; break | |
| yield from ( | |
| '<!DOCTYPE html>\n<html lang="en">\n<head>\n', | |
| '<meta charset="UTF-8">\n<meta name="viewport" content="width=device-width,initial-scale=1.0">\n', | |
| f'<title>{title}</title>\n<style>\n', | |
| '*{margin:0;padding:0;box-sizing:border-box}\n', | |
| 'body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;', | |
| 'background:linear-gradient(135deg,#0a0a1a 0%,#1a0a2e 50%,#0a1a2e 100%);color:#e0e0ff;min-height:100vh}\n', | |
| '.glass{background:rgba(255,255,255,.03);backdrop-filter:blur(20px);border:1px solid rgba(255,255,255,.06);border-radius:20px}\n', | |
| '</style>\n</head>\n<body>\n', | |
| '<div style="position:fixed;top:20px;left:50%;transform:translateX(-50%);z-index:100">\n', | |
| '<svg width="64" height="64" viewBox="0 0 64 64" id="hat" style="filter:drop-shadow(0 0 20px rgba(139,92,246,.6))">\n', | |
| '<defs><linearGradient id="g" x1="0%" y1="0%" x2="100%" y2="100%"><stop offset="0%" style="stop-color:#8B5CF6"/><stop offset="50%" style="stop-color:#06B6D4"/><stop offset="100%" style="stop-color:#10B981"/></linearGradient></defs>\n', | |
| '<path d="M32 8 L8 48 L32 40 L56 48 Z" fill="url(#g)" stroke="rgba(255,255,255,.3)" stroke-width="1.5"/>\n', | |
| '<ellipse cx="32" cy="48" rx="26" ry="7" fill="none" stroke="url(#g)" stroke-width="2" opacity=".6"/>\n', | |
| '</svg></div>\n', | |
| '<section style="display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;padding:2rem">\n', | |
| f'<h1 style="font-size:clamp(3rem,8vw,6rem);font-weight:800;background:linear-gradient(135deg,#8B5CF6,#06B6D4,#10B981);-webkit-background-clip:text;-webkit-text-fill-color:transparent;text-align:center">{title}</h1>\n', | |
| '<p style="font-size:1.25rem;color:#a0a0cc;margin-top:1.5rem;text-align:center;max-width:600px">Built with Wizard-Vibe Core — sandbox-first, hot-reload, A2A-native.</p>\n', | |
| '<div style="display:flex;gap:1rem;margin-top:2.5rem">\n', | |
| '<button style="padding:.875rem 2rem;background:linear-gradient(135deg,#8B5CF6,#06B6D4);border:none;border-radius:12px;color:#fff;font-size:1rem;font-weight:600;cursor:pointer">Get Started</button>\n', | |
| '<button style="padding:.875rem 2rem;background:rgba(255,255,255,.05);border:1px solid rgba(255,255,255,.1);border-radius:12px;color:#c0c0e0;font-size:1rem;font-weight:500;cursor:pointer">Learn More</button>\n', | |
| '</div></section>\n', | |
| '<section style="display:grid;grid-template-columns:repeat(auto-fit,minmax(280px,1fr));gap:2rem;padding:4rem 2rem;max-width:1200px;margin:0 auto">\n', | |
| '<div class="glass" style="padding:2rem"><h3 style="color:#8B5CF6">⚡ Sandbox-First</h3><p style="color:#9090b0;margin-top:.75rem">Every line executes in an isolated iframe sandbox before publish.</p></div>\n', | |
| '<div class="glass" style="padding:2rem"><h3 style="color:#06B6D4">🔄 Hot Reload</h3><p style="color:#9090b0;margin-top:.75rem">File watcher restarts server on every change — zero latency dev loop.</p></div>\n', | |
| '<div class="glass" style="padding:2rem"><h3 style="color:#10B981">🚀 A2A Native</h3><p style="color:#9090b0;margin-top:.75rem">Every deploy auto-generates agent.json for ecosystem discovery.</p></div>\n', | |
| '</section>\n', | |
| '<script>const h=document.getElementById("hat");let p=0;function a(){p+=.02;h.style.transform=`scale(${1+Math.sin(p)*.08})`;requestAnimationFrame(a)}a();</script>\n', | |
| '</body>\n</html>\n', | |
| ) | |
| def _game(self): | |
| yield from ( | |
| '<!DOCTYPE html>\n<html><head><meta charset="UTF-8"><title>Wizard-Vibe Game</title><style>', | |
| '*{margin:0;padding:0}body{background:#0a0a1a;color:#e0e0ff;font-family:sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;height:100vh}', | |
| 'canvas{border:1px solid rgba(255,255,255,.1);border-radius:12px}</style></head><body>', | |
| '<h2 style="background:linear-gradient(135deg,#8B5CF6,#06B6D4);-webkit-background-clip:text;-webkit-text-fill-color:transparent;margin-bottom:1rem">🧙♂️ Wizard-Vibe Game</h2>', | |
| '<canvas id="c" width="400" height="400"></canvas>', | |
| '<script>const c=document.getElementById("c"),x=c.getContext("2d");let bx=200,by=200,bvx=2,bvy=2;function d(){x.clearRect(0,0,400,400);x.beginPath();x.arc(bx,by,20,0,Math.PI*2);const g=x.createLinearGradient(bx-20,by,bx+20,by);g.addColorStop(0,"#8B5CF6");g.addColorStop(.5,"#06B6D4");g.addColorStop(1,"#10B981");x.fillStyle=g;x.fill();x.strokeStyle="rgba(255,255,255,.3)";x.lineWidth=2;x.stroke();bx+=bvx;by+=bvy;if(bx-20<0||bx+20>400)bvx=-bvx;if(by-20<0||by+20>400)bvy=-bvy;requestAnimationFrame(d)}d();</script>', | |
| '</body></html>\n', | |
| ) | |
| def _api(self): | |
| yield from ( | |
| 'from flask import Flask,request,jsonify\nfrom flask_cors import CORS\n\napp=Flask(__name__)\nCORS(app)\n\n', | |
| '@app.route("/api/health")\ndef health():\n return jsonify({"status":"ok","engine":"Wizard-Vibe"})\n\n', | |
| 'if __name__=="__main__":\n app.run(host="0.0.0.0",port=8080)\n', | |
| ) | |
| def _component(self): | |
| yield from ( | |
| '<template>\n <div class="wizard-card" :class="{active:isActive}">\n <div class="card-glass">\n', | |
| ' <h3>{{title}}</h3><p>{{description}}</p><button @click="toggle">{{label}}</button>\n </div>\n </div>\n</template>\n', | |
| '<script>export default{name:"WizardCard",props:{title:String,description:String,label:{type:String,default:"Activate"}},data(){return{isActive:false}},methods:{toggle(){this.isActive=!this.isActive;this.$emit("toggle",this.isActive)}}};</script>\n', | |
| '<style scoped>.wizard-card{border-radius:16px;overflow:hidden}.card-glass{background:rgba(255,255,255,.05);backdrop-filter:blur(20px);border:1px solid rgba(255,255,255,.08);padding:2rem}.active{box-shadow:0 0 30px rgba(139,92,246,.3)}</style>\n', | |
| ) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # REFLECT-SELECT — Self-Healing Engine | |
| # ═══════════════════════════════════════════════════════════════ | |
| class ReflectSelect: | |
| """Autonomous error detection and self-healing loop.""" | |
| VOID = {'br','hr','img','input','meta','link','area','base','col','embed','source','track','wbr'} | |
| PATTERNS = [ | |
| (r"console\.loge\(", "console.log("), | |
| (r"docment\.", "document."), | |
| (r"getElementbyId", "getElementById"), | |
| (r"innerHtml", "innerHTML"), | |
| (r"functon\s", "function "), | |
| (r"retrun", "return"), | |
| ] | |
| def heal(self, code: str, sandbox_errors: Optional[List[str]] = None) -> Tuple[str, int, int]: | |
| errors = self._detect(code) | |
| if sandbox_errors: errors.extend(sandbox_errors) | |
| found = len(errors) | |
| if not found: return code, 0, 0 | |
| fixed = 0 | |
| strategies = ["syntax", "logic", "structural"] | |
| for i in range(5): | |
| if not errors: break | |
| s = strategies[i % 3] | |
| if s == "syntax": code = self._fix_syntax(code) | |
| elif s == "logic": code = self._fix_logic(code) | |
| elif s == "structural": code = self._fix_structural(code) | |
| fixed += 1 | |
| errors = self._detect(code) | |
| return code, found, fixed | |
| def _detect(self, code: str) -> List[str]: | |
| e = [] | |
| if "<html" in code.lower() or code.startswith("<!"): | |
| e.extend(self._html_errors(code)) | |
| elif code.startswith("import") or "def " in code: | |
| try: compile(code, '<s>', 'exec') | |
| except SyntaxError as se: e.append(f"Syntax: {se}") | |
| if code.count('(') != code.count(')'): e.append("Parenthesis mismatch") | |
| if code.count('{') != code.count('}'): e.append("Brace mismatch") | |
| return e | |
| def _html_errors(self, code: str) -> List[str]: | |
| e, stack = [], [] | |
| for closing, tag in re.findall(r'<(/?)(\w+)', code, re.IGNORECASE): | |
| t = tag.lower() | |
| if t in self.VOID: continue | |
| if closing: | |
| if stack and stack[-1] == t: stack.pop() | |
| else: e.append(f"Unmatched </{tag}>") | |
| else: stack.append(t) | |
| for t in stack: e.append(f"Unclosed <{t}>") | |
| return e | |
| def _fix_syntax(self, code: str) -> str: | |
| for pat, rep in self.PATTERNS: code = re.sub(pat, rep, code) | |
| return code | |
| def _fix_logic(self, code: str) -> str: | |
| if 'fetch(' in code and '.catch' not in code: | |
| code = re.sub(r'(fetch\([^)]+\)[^;]*);', r'\1.catch(e => console.error(e));', code) | |
| return code | |
| def _fix_structural(self, code: str) -> str: | |
| c = code.strip() | |
| if ('<html' in c.lower() or '<body' in c.lower()) and not c.startswith('<!'): | |
| c = '<!DOCTYPE html>\n' + c | |
| if '<html' in c.lower() and not c.rstrip().endswith('</html>'): | |
| c = c.rstrip() + '\n</html>' | |
| return c | |
| # ═══════════════════════════════════════════════════════════════ | |
| # SANDBOX VALIDATOR | |
| # ═══════════════════════════════════════════════════════════════ | |
| def sandbox_validate(code: str) -> Dict: | |
| """Validate code in a logical sandbox — tag balancing, syntax checks.""" | |
| rs = ReflectSelect() | |
| errors = rs._detect(code) | |
| return {"success": len(errors) == 0, "errors": errors} | |
| # ═══════════════════════════════════════════════════════════════ | |
| # GLOBAL STATE | |
| # ═══════════════════════════════════════════════════════════════ | |
| class State: | |
| def __init__(self): | |
| self.orchestrator = Orchestrator() | |
| self.reflect = ReflectSelect() | |
| self.sessions: Dict = {} | |
| self.codes: Dict[str, str] = {} | |
| self.sandbox: Dict[str, str] = {} | |
| self.publish_ready: Dict[str, bool] = {} | |
| state = State() | |
| # ═══════════════════════════════════════════════════════════════ | |
| # SSE STREAMING — AsyncIterator[StreamResponse] | |
| # ═══════════════════════════════════════════════════════════════ | |
| async def stream_gen(sid: str, prompt: str): | |
| """Core streaming generator — yields SSE events.""" | |
| state.sessions[sid]["status"] = "streaming" | |
| state.sandbox[sid] = "building" | |
| # Phase 1: Orchestrate | |
| yield _sse("phase", {"phase": "orchestrate"}) | |
| plan = state.orchestrator.pose(prompt) | |
| yield _sse("plan", plan) | |
| # Phase 2: Generate | |
| yield _sse("phase", {"phase": "generate"}) | |
| code = "" | |
| for chunk in state.orchestrator.generate(prompt): | |
| code += chunk | |
| state.codes[sid] = code | |
| yield _sse("code", {"chunk": chunk, "partial": code}) | |
| await asyncio.sleep(0.03) | |
| # Phase 3: Reflect-Select | |
| yield _sse("phase", {"phase": "heal"}) | |
| healed, found, fixed = state.reflect.heal(code) | |
| state.codes[sid] = healed | |
| yield _sse("heal", {"found": found, "fixed": fixed}) | |
| # Phase 4: Sandbox | |
| yield _sse("phase", {"phase": "sandbox"}) | |
| result = sandbox_validate(healed) | |
| if result["success"]: | |
| state.sandbox[sid] = "stable" | |
| state.publish_ready[sid] = True | |
| yield _sse("sandbox", {"status": "stable"}) | |
| else: | |
| state.sandbox[sid] = "error" | |
| yield _sse("sandbox", {"status": "error", "errors": result["errors"]}) | |
| for attempt in range(3): | |
| healed, _, _ = state.reflect.heal(healed, result["errors"]) | |
| state.codes[sid] = healed | |
| result = sandbox_validate(healed) | |
| if result["success"]: | |
| state.sandbox[sid] = "stable" | |
| state.publish_ready[sid] = True | |
| yield _sse("sandbox", {"status": "stable", "heal_attempts": attempt + 1}) | |
| break | |
| yield _sse("heal", {"attempt": attempt + 1}) | |
| state.sessions[sid]["status"] = "complete" | |
| yield _sse("done", {"status": state.sandbox[sid]}) | |
| def _sse(event: str, data: dict) -> str: | |
| return f"event: {event}\ndata: {json.dumps(data)}\n\n" | |
| # ═══════════════════════════════════════════════════════════════ | |
| # HTTP HANDLERS | |
| # ═══════════════════════════════════════════════════════════════ | |
| async def handle_stream(request: web.Request) -> web.StreamResponse: | |
| sid = str(uuid.uuid4())[:8] | |
| data = await request.json() | |
| prompt = data.get("prompt", "") | |
| state.sessions[sid] = {"id": sid, "prompt": prompt, "status": "init"} | |
| state.sandbox[sid] = "building" | |
| state.publish_ready[sid] = False | |
| resp = web.StreamResponse(status=200, headers={ | |
| "Content-Type": "text/event-stream", | |
| "Cache-Control": "no-cache", | |
| "Connection": "keep-alive", | |
| "X-Accel-Buffering": "no", | |
| }) | |
| await resp.prepare(request) | |
| try: | |
| async for event in stream_gen(sid, prompt): | |
| await resp.write(event.encode()) | |
| await resp.write(b"event: close\ndata: {}\n\n") | |
| except Exception as e: | |
| await resp.write(f"event: error\ndata: {json.dumps({'error': str(e)})}\n\n".encode()) | |
| return resp | |
| async def handle_publish(request: web.Request) -> web.Response: | |
| data = await request.json() | |
| sid = data.get("session_id") | |
| repo = data.get("repo_name", f"wizard-vibe-{sid}") | |
| if not state.publish_ready.get(sid): | |
| return web.json_response({"error": "Sandbox not stable"}, status=400) | |
| code = state.codes.get(sid, "") | |
| if not code: | |
| return web.json_response({"error": "No code generated"}, status=400) | |
| # Save locally | |
| out = GENERATED_DIR / repo | |
| out.mkdir(exist_ok=True) | |
| (out / "index.html").write_text(code) | |
| # Generate agent card | |
| agent = { | |
| "name": repo, "description": f"Wizard-Vibe Core generated app", | |
| "url": f"https://dryymatt-{repo}.hf.space", | |
| "version": "1.0.0", "a2aVersion": "1.0", | |
| "capabilities": {"streaming": True}, | |
| "skills": [{"id": "vibe-deploy", "name": "Vibe Deploy", "tags": ["wizard-vibe", "core", "a2a"]}], | |
| } | |
| (out / "agent.json").write_text(json.dumps(agent, indent=2)) | |
| # Try GitHub push | |
| token = os.environ.get("GITHUB_TOKEN") or os.environ.get("HF_TOKEN") | |
| github = {"success": False} | |
| if token: | |
| try: | |
| async with aiohttp.ClientSession() as s: | |
| headers = {"Authorization": f"Bearer {token}", "Accept": "application/vnd.github+json"} | |
| u = (await s.get("https://api.github.com/user", headers=headers)).json() | |
| owner = u["login"] | |
| await s.post("https://api.github.com/user/repos", headers=headers, json={"name": repo, "auto_init": True}) | |
| for path in ["index.html", ".well-known/agent.json"]: | |
| content = (out / path).read_text() if (out / path).exists() else "" | |
| await s.put(f"https://api.github.com/repos/{owner}/{repo}/contents/{path}", headers=headers, json={ | |
| "message": f"✨ Wizard-Vibe Core: {path}", | |
| "content": base64.b64encode(content.encode()).decode(), | |
| }) | |
| github = {"success": True, "url": f"https://github.com/{owner}/{repo}"} | |
| except Exception as e: | |
| github = {"success": False, "error": str(e)} | |
| state.sessions[sid]["published"] = True | |
| return web.json_response({"success": True, "github": github, "agent": agent}) | |
| async def handle_health(request: web.Request) -> web.Response: | |
| return web.json_response({"status": "alive", "engine": "Wizard-Vibe Core", "sandbox_first": True, "hot_reload": HOT_RELOAD}) | |
| async def handle_agent_card(request: web.Request) -> web.Response: | |
| return web.json_response({ | |
| "name": "wizard-vibe-core", | |
| "description": "Wizard-Vibe Core — Sandbox-first SSE streaming code generator with Reflect-Select self-healing and A2A native deploy.", | |
| "url": "https://dryymatt-wizard-vibe-core.hf.space", | |
| "version": "1.0.0", "a2aVersion": "1.0", | |
| "capabilities": {"streaming": True, "pushNotifications": False, "stateTransitionHistory": True}, | |
| "skills": [ | |
| {"id": "code-generation", "name": "Code Generation", "tags": ["wizard-vibe", "core", "sse", "streaming"]}, | |
| {"id": "reflect-select", "name": "Reflect-Select Heal", "tags": ["self-healing", "error-fix"]}, | |
| {"id": "github-publish", "name": "GitHub Publish", "tags": ["deploy", "git", "a2a"]}, | |
| ], | |
| }) | |
| async def handle_preview(request: web.Request) -> web.Response: | |
| sid = request.query.get("session_id", "") | |
| code = state.codes.get(sid, "<!-- No code yet -->") | |
| return web.Response(text=code, content_type="text/html") | |
| async def handle_status(request: web.Request) -> web.Response: | |
| sid = request.query.get("session_id", "") | |
| if sid in state.sessions: | |
| return web.json_response({ | |
| "status": state.sessions[sid]["status"], | |
| "sandbox": state.sandbox.get(sid), | |
| "publish_ready": state.publish_ready.get(sid), | |
| }) | |
| return web.json_response({"sessions": len(state.sessions)}) | |
| async def handle_static(request: web.Request) -> web.Response: | |
| path = request.match_info.get("path", "index.html") | |
| fp = STATIC_DIR / path | |
| if not fp.exists() or not fp.is_file(): | |
| return web.Response(text="Not found", status=404) | |
| ct = {".html": "text/html", ".css": "text/css", ".js": "application/javascript", ".svg": "image/svg+xml"} | |
| return web.Response(text=fp.read_text(), content_type=ct.get(fp.suffix, "text/plain")) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # APP FACTORY | |
| # ═══════════════════════════════════════════════════════════════ | |
| def create_app() -> web.Application: | |
| app = web.Application() | |
| app.router.add_post("/api/stream", handle_stream) | |
| app.router.add_post("/api/publish", handle_publish) | |
| app.router.add_get("/api/status", handle_status) | |
| app.router.add_get("/api/preview", handle_preview) | |
| app.router.add_get("/api/health", handle_health) | |
| app.router.add_get("/.well-known/agent.json", handle_agent_card) | |
| app.router.add_get("/", handle_static) | |
| app.router.add_get("/{path:.*}", handle_static) | |
| return app | |
| def main(): | |
| print(f"🧙♂️ Wizard-Vibe Core [sandbox-first] :{PORT}") | |
| print(f" Hot-reload: {'ON' if HOT_RELOAD else 'OFF'}") | |
| print(f" Agent Card: /.well-known/agent.json") | |
| app = create_app() | |
| web.run_app(app, host="0.0.0.0", port=PORT) | |
| if __name__ == "__main__": | |
| main() | |