Omni-Vibe: updated server.py — Pose swarm + Pinggy tunnel

server.py

@@ -1,109 +1,285 @@
 """
-╔══════════════════════════════════════════════════════════╗
-║  WIZARD-VIBE STUDIO — Tokenless Autonomy Protocol      ║
-║  Ghost Deploy: HF Space → Live URL                     ║
-║  Reflect-Select: Zero-tolerance perfection             ║
-╚══════════════════════════════════════════════════════════╝
+╔══════════════════════════════════════════════════════╗
+║  OMNI-VIBE STUDIO — Specialized Swarm Server        ║
+║  Pose Architect · Pose Painter · Pose Auditor       ║
+║  LiteRT · Sub-Second · Shadow-Hosting               ║
+╚══════════════════════════════════════════════════════╝
 """
-import json, os, uuid, asyncio
+
+import json, os, uuid, asyncio, time
 from pathlib import Path
 from aiohttp import web
-from core import state as st, sandbox_validate
-from ghost_deploy import ghost, CANONICAL_REPO
+
+# Import the Omni-Vibe core — backward-compatible API
+from core import (
+    state as st, sandbox_validate,
+    Orchestrator, OmniVibeEngine, ReflectSelect,
+    PoseArchitect, PosePainter, PoseAuditor,
+)
+from ghost_deploy import ghost, CANONICAL_REPO, PinggyTunnel
 
 PORT = int(os.environ.get("WIZARD_PORT", 8765))
 STATIC = Path(__file__).parent / "static"
+WIZARD_HAT_COLOR = "steady-gold"  # The Athanor is active
+
+
+def _sse(ev, d):
+    return f"event: {ev}\ndata: {json.dumps(d)}\n\n"
 
-def _sse(ev, d): return f"event: {ev}\ndata: {json.dumps(d)}\n\n"
 
 async def stream_gen(sid, prompt):
-    st.sessions[sid]["status"] = "streaming"
+    """
+    Omni-Vibe streaming pipeline:
+    1. POSE — all three agents analyze in parallel
+    2. GENERATE — Pose Architect + Pose Painter produce code
+    3. AUDIT — Pose Auditor verifies step-by-step
+    4. HEAL — Reflect-Select loop until perfection
+    5. DEPLOY — Ghost Deploy to HF Spaces + Pinggy tunnel
+    """
+    session = st.sessions[sid]
+    session["status"] = "streaming"
     st.sandbox[sid] = "building"
-    yield _sse("phase", {"phase": "orchestrate"})
-    plan = st.orchestrator.pose(prompt)
-    yield _sse("plan", plan)
+
+    # Phase 1: Pose
+    yield _sse("phase", {"phase": "pose", "hat": WIZARD_HAT_COLOR})
+    await asyncio.sleep(0.05)
+
+    pose_plan = st.engine.pose(prompt)
+    yield _sse("pose", {
+        "architect": {
+            "stack": pose_plan["architect"]["stack"],
+            "features": pose_plan["architect"]["features"],
+            "files": pose_plan["architect"]["files_needed"],
+        },
+        "painter": pose_plan["painter"],
+        "auditor": pose_plan["auditor"],
+    })
+
+    # Phase 2: Generate
     yield _sse("phase", {"phase": "generate"})
-    code = ""
-    for chunk in st.orchestrator.generate(prompt):
-        code += chunk; st.codes[sid] = code
-        yield _sse("code", {"chunk": chunk, "partial": code})
-        await asyncio.sleep(0.03)
+    await asyncio.sleep(0.05)
+
+    t0 = time.time()
+    code, schema = st.engine.generate(prompt)
+    elapsed = (time.time() - t0) * 1000
+
+    # Stream in chunks for live UI
+    chunk_size = max(1, len(code) // 30)
+    for i in range(0, len(code), chunk_size):
+        chunk = code[i:i + chunk_size]
+        yield _sse("code", {
+            "chunk": chunk,
+            "partial": code[:i + chunk_size],
+            "progress": min(100, int((i + chunk_size) / len(code) * 100)),
+        })
+        await asyncio.sleep(0.015)
+
+    st.codes[sid] = code
+    st.sessions[sid]["schema"] = schema
+    yield _sse("generated", {
+        "chars": len(code),
+        "elapsed_ms": round(elapsed, 1),
+        "schema": {k: v for k, v in schema.items() if k != "files_needed"},
+    })
+
+    # Phase 3: Audit
+    yield _sse("phase", {"phase": "audit"})
+    await asyncio.sleep(0.05)
+
+    findings = st.engine.auditor.audit(code, schema)
+    yield _sse("audit", {
+        "findings": len(findings),
+        "errors": sum(1 for f in findings if f.severity == "ERROR"),
+        "warnings": sum(1 for f in findings if f.severity == "WARN"),
+        "details": [{"line": f.line, "severity": f.severity, "message": f.message}
+                     for f in findings[:5]],
+    })
+
+    # Phase 4: Heal (Reflect-Select)
     yield _sse("phase", {"phase": "heal"})
+
+    code, auto_fixes = st.engine.auditor.heal_findings(code, findings)
+    st.codes[sid] = code
+
     healed, found, fixed = st.reflect.heal(code)
-    st.codes[sid] = healed
-    yield _sse("heal", {"found": found, "fixed": fixed})
-    # Zero-tolerance: keep healing until perfect
-    total_heals = fixed
+    total_heals = fixed + auto_fixes
+
     for i in range(15):
         result = sandbox_validate(healed)
-        if result["success"]: break
-        healed, _, _ = st.reflect.heal(healed, result["errors"])
-        total_heals += 1; st.codes[sid] = healed
-        await asyncio.sleep(0.02)
+        if result["success"]:
+            break
+        healed, _, extra = st.reflect.heal(healed, result["errors"])
+        total_heals += extra
+        st.codes[sid] = healed
+        await asyncio.sleep(0.01)
+
+    yield _sse("heal", {
+        "auto_fixes": auto_fixes,
+        "reflect_fixes": fixed,
+        "total_heals": total_heals,
+        "loop_iterations": i + 1,
+    })
+
+    # Phase 5: Sandbox Validation
     yield _sse("phase", {"phase": "sandbox"})
     result = sandbox_validate(healed)
     if result["success"]:
-        st.sandbox[sid] = "stable"; st.publish_ready[sid] = True
-        yield _sse("sandbox", {"status": "stable", "errors": 0})
+        st.sandbox[sid] = "stable"
+        st.publish_ready[sid] = True
+        yield _sse("sandbox", {"status": "stable", "errors": 0, "hat": "steady-gold"})
     else:
         st.sandbox[sid] = "error"
         yield _sse("sandbox", {"status": "error", "errors": result["errors"]})
-    st.sessions[sid]["status"] = "complete"
-    yield _sse("done", {"status": st.sandbox[sid]})
+
+    session["status"] = "complete"
+    yield _sse("done", {
+        "status": st.sandbox[sid],
+        "hat": "steady-gold" if st.sandbox[sid] == "stable" else "red-glow",
+    })
+
 
 async def handle_stream(req):
-    sid = str(uuid.uuid4())[:8]; d = await req.json(); prompt = d.get("prompt","")
-    st.sessions[sid] = {"id":sid,"prompt":prompt,"status":"init"}
-    st.sandbox[sid]="building"; st.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"})
+    sid = str(uuid.uuid4())[:8]
+    d = await req.json()
+    prompt = d.get("prompt", "")
+
+    st.sessions[sid] = {"id": sid, "prompt": prompt, "status": "init"}
+    st.sandbox[sid] = "building"
+    st.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(req)
     try:
-        async for ev in stream_gen(sid, prompt): await resp.write(ev.encode())
+        async for ev in stream_gen(sid, prompt):
+            await resp.write(ev.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())
+        await resp.write(
+            f"event: error\ndata: {json.dumps({'error': str(e)})}\n\n".encode()
+        )
     return resp
 
+
 async def handle_publish(req):
-    d = await req.json(); sid = d.get("session_id")
-    vibe_name = d.get("vibe_name", f"vibe-{sid}")
+    d = await req.json()
+    sid = d.get("session_id")
+    vibe_name = d.get("vibe_name", f"omni-vibe-{sid}")
+
     if not st.publish_ready.get(sid):
-        return web.json_response({"success":False,"error":"Sandbox not stable — perfection required"}, status=400)
-    code = st.codes.get(sid,"")
-    if not code: return web.json_response({"success":False,"error":"No code"}, status=400)
-    description = d.get("description", st.sessions.get(sid,{}).get("prompt",""))
-    result = await ghost.publish(code, vibe_name, description[:200] if description else "")
+        return web.json_response(
+            {"success": False, "error": "Sandbox not stable — Pose Auditor requires perfection."},
+            status=400,
+        )
+
+    code = st.codes.get(sid, "")
+    if not code:
+        return web.json_response({"success": False, "error": "No code generated"}, status=400)
+
+    description = d.get("description", st.sessions.get(sid, {}).get("prompt", ""))
+    result = await ghost.publish(code, vibe_name, description[:200] if description else "", port=PORT)
+
     if result.get("success"):
         st.sessions[sid]["published"] = True
-        st.sessions[sid]["deploy_url"] = result.get("url")
+        st.sessions[sid]["deploy_url"] = result.get("space_url")
+        st.sessions[sid]["tunnel_url"] = result.get("tunnel_url")
+
     return web.json_response(result)
 
+
 async def handle_health(req):
-    return web.json_response({"status":"alive","engine":"Wizard-Vibe Studio — Ghost Deploy","protocol":"tokenless","registry":CANONICAL_REPO,"hf_token":bool(os.environ.get("HF_TOKEN"))})
+    return web.json_response({
+        "status": "alive",
+        "engine": "Omni-Vibe Studio — Specialized Swarm",
+        "protocol": "omni-vibe / tokenless / shadow-hosting",
+        "registry": CANONICAL_REPO,
+        "lifert": True,
+        "poses": {
+            "architect": "full-stack + zero-DB + Google OAuth",
+            "painter": "Liquid Glass design system",
+            "auditor": "step-by-step verification",
+        },
+        "hat": WIZARD_HAT_COLOR,
+        "hf_token": bool(os.environ.get("HF_TOKEN")),
+    })
+
 
 async def handle_agent(req):
-    return web.json_response(ghost.generate_agent_card("wizard-vibe-studio","Tokenless Ghost Deploy — HF Spaces + A2A native.","https://dryymatt-wizard-vibe-studio-v2.hf.space"))
+    return web.json_response(ghost.generate_agent_card(
+        "omni-vibe-studio",
+        "Omni-Vibe Studio — Specialized AI Swarm. Pose Architect designs full-stack schemas with zero-config DB and Google OAuth. Pose Painter enforces Liquid Glass design. Pose Auditor verifies step-by-step. LiteRT engine for sub-second latency.",
+        "https://dryymatt-wizard-vibe-studio-v2.hf.space",
+    ))
+
 
 async def handle_preview(req):
-    sid = req.query.get("session_id","")
-    return web.Response(text=st.codes.get(sid,"<!-- No code -->"), content_type="text/html")
+    sid = req.query.get("session_id", "")
+    return web.Response(
+        text=st.codes.get(sid, "<!-- Omni-Vibe — no code -->"),
+        content_type="text/html",
+    )
+
 
 async def handle_status(req):
-    sid = req.query.get("session_id","")
+    sid = req.query.get("session_id", "")
     if sid in st.sessions:
         s = st.sessions[sid]
-        return web.json_response({"status":s["status"],"sandbox":st.sandbox.get(sid),"ready":st.publish_ready.get(sid),"deploy_url":s.get("deploy_url")})
-    return web.json_response({"sessions":len(st.sessions)})
+        return web.json_response({
+            "status": s["status"],
+            "sandbox": st.sandbox.get(sid),
+            "ready": st.publish_ready.get(sid),
+            "deploy_url": s.get("deploy_url"),
+            "tunnel_url": s.get("tunnel_url"),
+            "hat": "steady-gold" if st.publish_ready.get(sid) else "cyan-blink",
+        })
+    return web.json_response({
+        "sessions": len(st.sessions),
+        "engine": "omni-vibe",
+        "hat": WIZARD_HAT_COLOR,
+    })
+
 
 async def handle_vibes(req):
     vibes = await ghost.list_vibes()
-    return web.json_response({"vibes":vibes,"count":len(vibes),"registry":CANONICAL_REPO})
+    return web.json_response({
+        "vibes": vibes,
+        "count": len(vibes),
+        "registry": CANONICAL_REPO,
+    })
+
+
+async def handle_tunnel(req):
+    """Bring up an ephemeral Pinggy/Cloudflare tunnel for instant preview."""
+    try:
+        url = await ghost.tunnel.up(PORT, timeout=10.0)
+        return web.json_response({"success": bool(url), "url": url})
+    except Exception as e:
+        return web.json_response({"success": False, "error": str(e)}, status=500)
+
+
+async def handle_schema(req):
+    """Get the full-stack schema for the current session."""
+    sid = req.query.get("session_id", "")
+    s = st.sessions.get(sid, {})
+    schema = s.get("schema", {})
+    return web.json_response(schema)
+
 
 async def handle_static(req):
-    path = req.match_info.get("path","index.html"); fp = STATIC/path
-    if not fp.exists(): return web.Response(text="Not found", status=404)
-    ct = {".html":"text/html",".css":"text/css",".js":"application/javascript"}
-    return web.Response(text=fp.read_text(), content_type=ct.get(fp.suffix,"text/plain"))
+    path = req.match_info.get("path", "index.html")
+    fp = STATIC / path
+    if not fp.exists():
+        return web.Response(text="Not found", status=404)
+    ct = {".html": "text/html", ".css": "text/css", ".js": "application/javascript"}
+    return web.Response(text=fp.read_text(), content_type=ct.get(fp.suffix, "text/plain"))
+
 
 def create_app():
     app = web.Application()
@@ -113,15 +289,24 @@ def create_app():
     app.router.add_get("/api/preview", handle_preview)
     app.router.add_get("/api/health", handle_health)
     app.router.add_get("/api/vibes", handle_vibes)
+    app.router.add_get("/api/tunnel", handle_tunnel)
+    app.router.add_get("/api/schema", handle_schema)
     app.router.add_get("/.well-known/agent.json", handle_agent)
     app.router.add_get("/", handle_static)
     app.router.add_get("/{path:.*}", handle_static)
     return app
 
+
 def main():
-    print(f"🧙‍♂️ Wizard-Vibe Studio — Ghost Deploy Protocol")
-    print(f"   Registry: {CANONICAL_REPO}")
-    print(f"   Zero-tolerance sandbox perfection")
+    print(f"🧙‍♂️ Omni-Vibe Studio — Specialized Swarm")
+    print(f"   Pose Architect : full-stack + zero-DB + Google OAuth")
+    print(f"   Pose Painter   : Liquid Glass design system")
+    print(f"   Pose Auditor   : step-by-step verification")
+    print(f"   Athanor        : LiteRT engine, sub-second latency")
+    print(f"   Registry       : {CANONICAL_REPO}")
+    print(f"   Hat            : {WIZARD_HAT_COLOR}")
     web.run_app(create_app(), host="0.0.0.0", port=PORT)
 
-if __name__ == "__main__": main()
+
+if __name__ == "__main__":
+    main()