| """ |
| ╔══════════════════════════════════════════════════════════╗ |
| ║ OMNI-VIBE CORE — Specialized Swarm Architecture ║ |
| ║ ║ |
| ║ The Athanor: LiteRT engine, sub-second latency ║ |
| ║ ║ |
| ║ POSE ARCHITECT: full-stack schema + zero-config DB ║ |
| ║ + Google OAuth out-of-the-box ║ |
| ║ POSE PAINTER: Liquid Glass design system enforced ║ |
| ║ across every generated app ║ |
| ║ POSE AUDITOR: step-by-step reasoning, verify code ║ |
| ║ before every hot-reload ║ |
| ║ ║ |
| ║ All Poses run locally — zero external API calls. ║ |
| ║ Sub-second Reflect-Select loop with regex engine. ║ |
| ╚══════════════════════════════════════════════════════════╝ |
| """ |
|
|
| import asyncio, json, os, re, time, uuid, textwrap, hashlib |
| from pathlib import Path |
| from typing import Dict, List, Optional, Tuple |
| from dataclasses import dataclass, field |
|
|
|
|
| |
| |
| |
|
|
| @dataclass |
| class AuditFinding: |
| line: int |
| severity: str |
| message: str |
| fix: Optional[str] = None |
|
|
|
|
| |
| |
|
|
| LIQUID_GLASS_CSS = """ |
| :root { |
| --glass-bg: rgba(255,255,255,.03); |
| --glass-border: rgba(255,255,255,.06); |
| --glass-hover: rgba(255,255,255,.08); |
| --purple: #8B5CF6; --cyan: #06B6D4; --green: #10B981; --gold: #F59E0B; |
| --text: #e0e0ff; --text2: #9090b0; --text3: #606080; |
| --bg1: #0a0a1a; --bg2: #1a0a2e; |
| --radius: 20px; --radius-sm: 12px; |
| --font: -apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif; |
| --mono: 'SF Mono','Fira Code',monospace; |
| } |
| *,*::before,*::after{box-sizing:border-box;margin:0;padding:0} |
| body{font-family:var(--font);background:linear-gradient(135deg,var(--bg1),var(--bg2),#0a1a2e);color:var(--text);min-height:100vh;-webkit-font-smoothing:antialiased} |
| ::selection{background:rgba(139,92,246,.5);color:#fff} |
| .glass{background:var(--glass-bg);backdrop-filter:blur(20px);-webkit-backdrop-filter:blur(20px);border:1px solid var(--glass-border);border-radius:var(--radius)} |
| .glass-hover:hover{background:var(--glass-hover);border-color:rgba(139,92,246,.2)} |
| .btn{display:inline-flex;align-items:center;gap:.5rem;padding:.75rem 1.75rem;background:linear-gradient(135deg,var(--purple),var(--cyan));border:none;border-radius:var(--radius-sm);color:#fff;font-weight:600;cursor:pointer;transition:transform .15s,box-shadow .15s} |
| .btn:hover{transform:translateY(-1px);box-shadow:0 4px 20px rgba(139,92,246,.4)} |
| .btn-outline{background:var(--glass-bg);border:1px solid var(--glass-border);color:var(--text2)} |
| .input-glass{width:100%;padding:.75rem 1rem;background:var(--glass-bg);border:1px solid var(--glass-border);border-radius:var(--radius-sm);color:var(--text);font-size:.95rem;outline:none;transition:border-color .15s,box-shadow .15s} |
| .input-glass:focus{border-color:rgba(139,92,246,.4);box-shadow:0 0 20px rgba(139,92,246,.1)} |
| .card{background:var(--glass-bg);backdrop-filter:blur(20px);border:1px solid var(--glass-border);border-radius:var(--radius);padding:1.5rem} |
| .gradient-text{background:linear-gradient(135deg,var(--purple),var(--cyan),var(--green));-webkit-background-clip:text;-webkit-text-fill-color:transparent} |
| """ |
|
|
| LIQUID_GLASS_LOGO = """ |
| <svg width="48" height="48" viewBox="0 0 64 64" id="wizard-hat" style="filter:drop-shadow(0 0 20px rgba(139,92,246,.6))"> |
| <defs><linearGradient id="hg" 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> |
| <path d="M32 8 L8 48 L32 40 L56 48 Z" fill="url(#hg)" stroke="rgba(255,255,255,.3)" stroke-width="1.5"/> |
| <ellipse cx="32" cy="48" rx="26" ry="7" fill="none" stroke="url(#hg)" stroke-width="2" opacity=".6"/> |
| </svg> |
| """ |
|
|
| |
|
|
| ZERO_DB_SCHEMA = """ |
| -- Omni-Vibe Zero-Config Database |
| -- Uses SQLite (built-in, zero setup) with WAL mode |
| |
| CREATE TABLE IF NOT EXISTS users ( |
| id TEXT PRIMARY KEY, |
| email TEXT UNIQUE NOT NULL, |
| name TEXT, |
| avatar_url TEXT, |
| google_id TEXT UNIQUE, |
| created_at TEXT DEFAULT (datetime('now')), |
| updated_at TEXT DEFAULT (datetime('now')) |
| ); |
| |
| CREATE TABLE IF NOT EXISTS sessions ( |
| id TEXT PRIMARY KEY, |
| user_id TEXT NOT NULL REFERENCES users(id), |
| token TEXT UNIQUE NOT NULL, |
| expires_at TEXT NOT NULL, |
| created_at TEXT DEFAULT (datetime('now')) |
| ); |
| |
| CREATE TABLE IF NOT EXISTS items ( |
| id TEXT PRIMARY KEY, |
| user_id TEXT NOT NULL REFERENCES users(id), |
| title TEXT NOT NULL, |
| content TEXT, |
| status TEXT DEFAULT 'active', |
| created_at TEXT DEFAULT (datetime('now')), |
| updated_at TEXT DEFAULT (datetime('now')) |
| ); |
| |
| CREATE INDEX IF NOT EXISTS idx_items_user ON items(user_id); |
| CREATE INDEX IF NOT EXISTS idx_sessions_token ON sessions(token); |
| """ |
|
|
| |
|
|
| GOOGLE_OAUTH_PY = """ |
| import os, json, httpx |
| from urllib.parse import urlencode |
| |
| GOOGLE_CLIENT_ID = os.environ.get("GOOGLE_CLIENT_ID", "") |
| GOOGLE_CLIENT_SECRET = os.environ.get("GOOGLE_CLIENT_SECRET", "") |
| GOOGLE_REDIRECT = os.environ.get("GOOGLE_REDIRECT_URI", "http://localhost:8080/auth/callback") |
| |
| def get_auth_url(state: str = "") -> str: |
| params = { |
| "client_id": GOOGLE_CLIENT_ID, |
| "redirect_uri": GOOGLE_REDIRECT, |
| "response_type": "code", |
| "scope": "openid email profile", |
| "state": state, |
| } |
| return f"https://accounts.google.com/o/oauth2/v2/auth?{urlencode(params)}" |
| |
| async def exchange_code(code: str) -> dict: |
| async with httpx.AsyncClient() as c: |
| resp = await c.post("https://oauth2.googleapis.com/token", data={ |
| "code": code, "client_id": GOOGLE_CLIENT_ID, |
| "client_secret": GOOGLE_CLIENT_SECRET, |
| "redirect_uri": GOOGLE_REDIRECT, "grant_type": "authorization_code", |
| }) |
| tokens = resp.json() |
| user = await c.get("https://www.googleapis.com/oauth2/v2/userinfo", |
| headers={"Authorization": f"Bearer {tokens['access_token']}"}) |
| return {**tokens, "user": user.json()} |
| """ |
|
|
| GOOGLE_OAUTH_JS = """ |
| // Google OAuth client-side — Liquid Glass styled |
| async function initGoogleAuth() { |
| const btn = document.getElementById('google-auth-btn'); |
| if (!btn) return; |
| |
| btn.addEventListener('click', () => { |
| const state = crypto.randomUUID(); |
| localStorage.setItem('oauth_state', state); |
| window.location.href = `/auth/google?state=${state}`; |
| }); |
| |
| // Check for callback |
| const params = new URLSearchParams(window.location.search); |
| if (params.get('code')) { |
| const resp = await fetch('/auth/callback?' + params.toString()); |
| const data = await resp.json(); |
| if (data.user) { |
| localStorage.setItem('user', JSON.stringify(data.user)); |
| window.location.href = '/'; |
| } |
| } |
| } |
| document.addEventListener('DOMContentLoaded', initGoogleAuth); |
| """ |
|
|
|
|
| |
| |
| |
|
|
| class PoseArchitect: |
| """ |
| Generates full-stack application architectures. |
| Every output includes: zero-config SQLite DB + Google OAuth. |
| """ |
|
|
| STACKS = { |
| "html": {"backend": None, "frontend": "Vanilla HTML/CSS/JS + Liquid Glass"}, |
| "flask": {"backend": "Flask+SQLite","frontend": "Jinja2 + Liquid Glass"}, |
| "fastapi": {"backend": "FastAPI+SQLite","frontend": "HTMX + Liquid Glass"}, |
| "node": {"backend": "Express+better-sqlite3","frontend": "Vanilla + Liquid Glass"}, |
| } |
|
|
| def design(self, prompt: str) -> Dict: |
| """Analyze prompt and design the full-stack schema.""" |
| p = prompt.lower() |
|
|
| |
| stack = "html" |
| if any(w in p for w in ["api","backend","server","flask","fastapi"]): |
| stack = "fastapi" if "fastapi" in p else "flask" |
| elif any(w in p for w in ["node","express","javascript backend"]): |
| stack = "node" |
| elif any(w in p for w in ["app","saas","platform","dashboard","database"]): |
| stack = "fastapi" |
|
|
| |
| features = [] |
| if any(w in p for w in ["auth","login","signup","oauth","google"]): |
| features.append("google-oauth") |
| if any(w in p for w in ["database","db","storage","data","crud"]): |
| features.append("zero-db") |
| if any(w in p for w in ["dashboard","admin","panel"]): |
| features.append("dashboard") |
| if any(w in p for w in ["landing","page","homepage","marketing"]): |
| features.append("landing-page") |
| if any(w in p for w in ["dark","theme","purple","glass","gradient"]): |
| features.append("liquid-glass-theme") |
|
|
| schema = { |
| "stack": self.STACKS[stack], |
| "features": features, |
| "has_db": "zero-db" in features, |
| "has_auth": "google-oauth" in features, |
| "has_dashboard": "dashboard" in features, |
| "files_needed": self._compute_files(stack, features), |
| "landing_title": self._extract_title(prompt), |
| } |
| return schema |
|
|
| def _compute_files(self, stack: str, features: List[str]) -> List[str]: |
| files = ["index.html"] |
| if "google-oauth" in features: |
| files.extend(["auth.py", "static/auth.js"]) |
| if "zero-db" in features: |
| files.append("database.py") |
| if stack in ("flask", "fastapi"): |
| files.extend(["app.py", "requirements.txt"]) |
| if stack == "fastapi": |
| files.append("Dockerfile") |
| if "dashboard" in features: |
| files.append("templates/dashboard.html") |
| return files |
|
|
| def _extract_title(self, prompt: str) -> str: |
| """Extract a meaningful title from the prompt.""" |
| for phrase in ["called ", "named ", "titled "]: |
| if phrase in prompt.lower(): |
| idx = prompt.lower().find(phrase) + len(phrase) |
| end = min(prompt.find(" ", idx + 1) if " " in prompt[idx:] else len(prompt), idx + 30) |
| name = prompt[idx:end].strip().rstrip(".,;!?") |
| if name: return name |
| for w in ["startup", "saas", "app", "platform", "labs", "studio"]: |
| if w in prompt.lower(): |
| return f"{w.title()} — Omni-Vibe" |
| return "Omni-Vibe App" |
|
|
| def generate_backend(self, schema: Dict) -> str: |
| """Generate zero-config backend code.""" |
| if not schema["has_db"] and not schema["has_auth"]: |
| return "" |
|
|
| code = [] |
| if schema["stack"]["backend"] and "Flask" in schema["stack"]["backend"]: |
| code.append("from flask import Flask, request, jsonify, redirect, session\n") |
| code.append("import sqlite3, os, uuid, hashlib\n\n") |
| code.append("app = Flask(__name__)\napp.secret_key = os.environ.get('SECRET_KEY', 'omni-vibe-dev')\n\n") |
| code.append("# ─── Zero-Config Database ───\n") |
| code.append("DB = os.environ.get('DATABASE_URL', 'app.db')\n\n") |
| code.append("def get_db():\n conn = sqlite3.connect(DB)\n conn.row_factory = sqlite3.Row\n conn.execute('PRAGMA journal_mode=WAL')\n return conn\n\n") |
| code.append("# ─── Init Schema ───\n") |
| code.append("def init_db():\n with get_db() as db:\n") |
| for line in ZERO_DB_SCHEMA.strip().split("\n"): |
| if line.strip() and not line.startswith("--"): |
| code.append(f" db.execute('''{line.strip()}''')\n") |
| code.append(" print('✅ Omni-Vibe DB initialized')\n\ninit_db()\n\n") |
|
|
| if schema["has_auth"]: |
| code.append("# ─── Google OAuth ───\n") |
| code.append(GOOGLE_OAUTH_PY.strip() + "\n\n") |
|
|
| elif schema["stack"]["backend"] and "FastAPI" in schema["stack"]["backend"]: |
| code.append("from fastapi import FastAPI, Request, HTTPException\n") |
| code.append("from fastapi.responses import JSONResponse, RedirectResponse\n") |
| code.append("import sqlite3, os, uuid\n\n") |
| code.append("app = FastAPI(title='Omni-Vibe')\n\n") |
|
|
| return "".join(code) |
|
|
|
|
| |
| |
| |
|
|
| class PosePainter: |
| """ |
| Enforces the Liquid Glass design system on every generated app. |
| Injects canonical CSS, logo SVG, and ensures consistent theming. |
| """ |
|
|
| LG_COMPONENTS = { |
| "navbar": """ |
| <nav class="glass" style="padding:1rem 2rem;display:flex;align-items:center;justify-content:space-between"> |
| <div style="display:flex;align-items:center;gap:.75rem"> |
| {LOGO} |
| <span class="gradient-text" style="font-weight:700;font-size:1.1rem">{TITLE}</span> |
| </div> |
| <div style="display:flex;gap:1rem"> |
| <a href="/" class="btn-outline btn" style="padding:.5rem 1rem;font-size:.85rem">Home</a> |
| <a href="/dashboard" class="btn-outline btn" style="padding:.5rem 1rem;font-size:.85rem">Dashboard</a> |
| <button id="google-auth-btn" class="btn" style="padding:.5rem 1rem;font-size:.85rem">Sign In</button> |
| </div> |
| </nav> |
| """, |
| "hero": """ |
| <section style="display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:80vh;padding:2rem;text-align:center"> |
| <h1 class="gradient-text" style="font-size:clamp(2.5rem,8vw,5rem);font-weight:800;line-height:1.1">{TITLE}</h1> |
| <p style="font-size:1.25rem;color:var(--text2);margin-top:1.5rem;max-width:600px">{SUBTITLE}</p> |
| <div style="display:flex;gap:1rem;margin-top:2.5rem"> |
| <button class="btn" onclick="document.getElementById('cta-section').scrollIntoView({behavior:'smooth'})">Get Started</button> |
| <button class="btn btn-outline">Learn More</button> |
| </div> |
| </section> |
| """, |
| "features": """ |
| <section style="display:grid;grid-template-columns:repeat(auto-fit,minmax(280px,1fr));gap:1.5rem;padding:3rem 2rem;max-width:1200px;margin:0 auto"> |
| {FEATURE_CARDS} |
| </section> |
| """, |
| "feature_card": """ |
| <div class="card glass-hover"> |
| <div style="font-size:2rem;margin-bottom:.75rem">{ICON}</div> |
| <h3 style="color:var(--{COLOR});font-size:1.15rem;margin-bottom:.5rem">{TITLE}</h3> |
| <p style="color:var(--text2);font-size:.9rem;line-height:1.5">{DESCRIPTION}</p> |
| </div> |
| """, |
| "footer": """ |
| <footer class="glass" style="margin-top:3rem;padding:2rem;text-align:center;color:var(--text3);font-size:.85rem"> |
| <p>Built with <span class="gradient-text" style="font-weight:600">Omni-Vibe Studio</span> — Liquid Glass Design System</p> |
| <p style="margin-top:.5rem">Zero-config · Google OAuth · SQLite · Pinggy Deploy</p> |
| </footer> |
| """, |
| } |
|
|
| def paint(self, code: str, schema: Dict) -> str: |
| """Inject Liquid Glass design system into generated code.""" |
| title = schema.get("landing_title", "Omni-Vibe App") |
|
|
| |
| if "liquid-glass" not in code.lower() and "--glass-bg" not in code: |
| code = code.replace("</head>", |
| f"<style>\n/* Liquid Glass Design System — Omni-Vibe */\n{LIQUID_GLASS_CSS.strip()}\n</style>\n</head>") |
|
|
| |
| code = code.replace("<!-- WIZARD-LOGO -->", LIQUID_GLASS_LOGO) |
|
|
| |
| if "<nav" not in code.lower() and "navbar" not in code.lower() and schema.get("has_auth"): |
| navbar = self.LG_COMPONENTS["navbar"].replace("{LOGO}", LIQUID_GLASS_LOGO).replace("{TITLE}", title) |
| code = code.replace("<body>", f"<body>\n{navbar}") |
|
|
| |
| if "gradient-text" not in code and ".gradient-text" not in code: |
| if "</style>" in code: |
| code = code.replace("</style>", |
| ".gradient-text{background:linear-gradient(135deg,var(--purple),var(--cyan),var(--green));-webkit-background-clip:text;-webkit-text-fill-color:transparent}\n</style>") |
|
|
| |
| if schema.get("has_auth") and "google-auth" not in code: |
| code = code.replace("</body>", |
| f"<script>\n{GOOGLE_OAUTH_JS.strip()}\n</script>\n</body>") |
|
|
| return code |
|
|
|
|
| |
| |
| |
|
|
| class PoseAuditor: |
| """ |
| Step-by-step reasoning: verifies code correctness before hot-reload. |
| Returns structured findings with severity and suggested fixes. |
| """ |
|
|
| VOID = {'br','hr','img','input','meta','link','area','base','col','embed','source','track','wbr'} |
| SVG_VOID = VOID | {'lineargradient','defs','stop','animate','animatetransform','fegaussianblur','femerge','femergenode','ellipse','path','circle','rect','polygon','polyline','g','use','svg'} |
|
|
| def audit(self, code: str, schema: Dict = None) -> List[AuditFinding]: |
| """Full audit: HTML validity, JS correctness, accessibility, security, simplicity.""" |
| findings = [] |
|
|
| |
| findings.extend(self._audit_html(code)) |
|
|
| |
| findings.extend(self._audit_js(code)) |
|
|
| |
| if schema and schema.get("features"): |
| findings.extend(self._audit_liquid_glass(code)) |
|
|
| |
| findings.extend(self._audit_simplicity(code, schema)) |
|
|
| |
| findings.extend(self._audit_security(code, schema)) |
|
|
| return findings |
|
|
| def _audit_html(self, code: str) -> List[AuditFinding]: |
| findings = [] |
| stack = [] |
|
|
| for m in re.finditer(r'<(?P<closing>/)?(?P<tag>\w+)(?:\s[^>]*?)?(?P<self>/)?>', code, re.IGNORECASE): |
| t = m.group('tag').lower() |
| if t in self.SVG_VOID: continue |
| if m.group('self'): continue |
| if m.group('closing'): |
| if stack and stack[-1] == t: stack.pop() |
| else: findings.append(AuditFinding( |
| line=code[:m.start()].count('\n')+1, severity="ERROR", |
| message=f"Unmatched closing tag </{t}>", |
| fix=f"Remove or match with opening <{t}>")) |
| else: stack.append(t) |
|
|
| for t in stack: |
| findings.append(AuditFinding( |
| line=1, severity="ERROR", |
| message=f"Unclosed tag <{t}>", |
| fix=f"Add </{t}> before parent closes")) |
|
|
| |
| if '<html' in code.lower() and not code.strip().startswith('<!'): |
| findings.append(AuditFinding(line=1, severity="WARN", |
| message="Missing DOCTYPE declaration", |
| fix="Add <!DOCTYPE html> at line 1")) |
|
|
| return findings |
|
|
| def _audit_js(self, code: str) -> List[AuditFinding]: |
| findings = [] |
| scripts = re.findall(r'<script[^>]*>(.*?)</script>', code, re.DOTALL | re.IGNORECASE) |
|
|
| for i, script in enumerate(scripts): |
| lines = script.split('\n') |
| for ln, line in enumerate(lines, 1): |
| |
| typos = { |
| "console.loge(": "console.log(", |
| "docment.": "document.", |
| "getElementbyId": "getElementById", |
| "innerHtml": "innerHTML", |
| "functon ": "function ", |
| "retrun": "return", |
| "alet(": "alert(", |
| "consts ": "const ", |
| } |
| for typo, fix in typos.items(): |
| if typo in line: |
| findings.append(AuditFinding( |
| line=ln, severity="ERROR", |
| message=f"Typo: {typo.strip('(')} → {fix.strip('(')}", |
| fix=f"Replace '{typo}' with '{fix}'")) |
|
|
| return findings |
|
|
| def _audit_liquid_glass(self, code: str) -> List[AuditFinding]: |
| findings = [] |
| if "--glass-bg" not in code and "var(--glass" not in code: |
| findings.append(AuditFinding(line=1, severity="WARN", |
| message="Liquid Glass CSS variables not detected", |
| fix="Inject Liquid Glass design system CSS")) |
| return findings |
|
|
| def _audit_security(self, code: str, schema: Dict) -> List[AuditFinding]: |
| findings = [] |
| |
| if re.search(r'\.innerHTML\s*=', code) and "sanitize" not in code.lower(): |
| findings.append(AuditFinding(line=1, severity="WARN", |
| message="innerHTML assignment detected without sanitization — XSS risk", |
| fix="Use textContent or DOMPurify.sanitize()")) |
| return findings |
|
|
| def _audit_simplicity(self, code: str, schema: Dict) -> List[AuditFinding]: |
| """ |
| STABLE VIBE: Verify Painter produced a single, elegant Liquid Glass |
| landing page — no SaaS complexity, no broken asset paths. |
| """ |
| findings = [] |
|
|
| |
| saas_routes = ['/dashboard', '/admin', '/settings', '/login', '/register', '/signup', |
| '/api/', '/app/', '/profile', '/billing', '/tasks', '/items'] |
| for route in saas_routes: |
| if route in code and f'href="{route}"' in code: |
| findings.append(AuditFinding(line=1, severity="ERROR", |
| message=f"SaaS route detected: {route} — STABLE VIBE requires single landing page", |
| fix=f"Remove navigation link to {route}")) |
|
|
| |
| db_patterns = ['CREATE TABLE', 'INSERT INTO', 'sqlite3', 'better-sqlite3', |
| 'mongoose', 'prisma', 'supabase', 'firebase', 'mongodb'] |
| for pat in db_patterns: |
| if pat.lower() in code.lower(): |
| findings.append(AuditFinding(line=1, severity="ERROR", |
| message=f"Database reference '{pat}' found in HTML — strip backend complexity", |
| fix="Remove database initialization from frontend code")) |
|
|
| |
| external_assets = re.findall(r'(?:src|href)=["\'](https?://[^"\']+)["\']', code) |
| |
| allowed_prefixes = ('https://huggingface.co', 'https://accounts.google.com', |
| 'https://oauth2.googleapis.com', 'https://fonts.googleapis.com', |
| 'https://cdnjs.cloudflare.com', 'https://fonts.gstatic.com') |
| for asset in external_assets: |
| if not any(asset.startswith(p) for p in allowed_prefixes): |
| findings.append(AuditFinding(line=1, severity="WARN", |
| message=f"External asset: {asset[:80]} — prefer inline or relative paths", |
| fix="Inline the resource or use a relative path")) |
|
|
| |
| html_count = len(re.findall(r'<html', code, re.IGNORECASE)) |
| if html_count > 1: |
| findings.append(AuditFinding(line=1, severity="ERROR", |
| message=f"Multiple <html> documents ({html_count}) — must be single page", |
| fix="Merge into one HTML document")) |
|
|
| |
| if "--glass-bg" not in code and "var(--glass" not in code: |
| findings.append(AuditFinding(line=1, severity="ERROR", |
| message="Liquid Glass CSS variables missing — Painter must enforce", |
| fix="Inject the Liquid Glass design system CSS")) |
|
|
| |
| if 'wizard-hat' not in code.lower() and 'wizard_hat' not in code.lower(): |
| findings.append(AuditFinding(line=1, severity="WARN", |
| message="Wizard hat SVG missing — brand element required", |
| fix="Add the wizard hat SVG logo")) |
|
|
| return findings |
|
|
| def heal_findings(self, code: str, findings: List[AuditFinding]) -> Tuple[str, int]: |
| """Apply all ERROR-level fixes.""" |
| fixed = code |
| count = 0 |
| for f in findings: |
| if f.severity == "ERROR" and f.fix: |
| |
| for typo, fix in [ |
| ("console.loge(", "console.log("), |
| ("docment.", "document."), |
| ("getElementbyId", "getElementById"), |
| ("innerHtml", "innerHTML"), |
| ("functon ", "function "), |
| ("retrun", "return"), |
| ("alet(", "alert("), |
| ]: |
| if typo in fixed: |
| fixed = fixed.replace(typo, fix) |
| count += 1 |
| return fixed, count |
|
|
|
|
| |
| |
| |
|
|
| class OmniVibeEngine: |
| """The Athanor: all three Poses running as a synchronized swarm.""" |
|
|
| def __init__(self): |
| self.architect = PoseArchitect() |
| self.painter = PosePainter() |
| self.auditor = PoseAuditor() |
|
|
| def pose(self, prompt: str) -> Dict: |
| """All three Poses analyze the prompt in parallel.""" |
| return { |
| "architect": self.architect.design(prompt), |
| "painter": {"design_system": "Liquid Glass", "components": sorted(self.painter.LG_COMPONENTS.keys())}, |
| "auditor": {"strategy": "step-by-step reasoning", "checks": ["HTML validity", "JS correctness", "Liquid Glass compliance", "Simplicity (no SaaS)", "Security"]}, |
| } |
|
|
| def generate(self, prompt: str) -> Tuple[str, Dict]: |
| """ |
| Full Omni-Vibe generation: |
| 1. Architect designs the full-stack schema |
| 2. Painter enforces Liquid Glass design |
| 3. Auditor verifies every line |
| Returns (code, schema) |
| """ |
| schema = self.architect.design(prompt) |
|
|
| |
| if schema["features"] and any(f in schema["features"] for f in ["landing-page", "dashboard"]): |
| code = self._generate_frontend(prompt, schema) |
| elif schema["stack"]["backend"]: |
| code = self.architect.generate_backend(schema) |
| else: |
| code = self._generate_frontend(prompt, schema) |
|
|
| |
| code = self.painter.paint(code, schema) |
|
|
| |
| findings = self.auditor.audit(code, schema) |
| code, fixes = self.auditor.heal_findings(code, findings) |
|
|
| return code, schema |
|
|
| def _generate_frontend(self, prompt: str, schema: Dict) -> str: |
| """Generate a Liquid Glass frontend.""" |
| title = schema["landing_title"] |
| has_auth = schema.get("has_auth", False) |
|
|
| features_html = "" |
| default_features = [ |
| ("⚡", "purple", "Zero-Delay", "Real-time streaming with sub-second hot reload in sandboxed iframe."), |
| ("🔄", "cyan", "Reflect-Select", "Autonomous code healing — errors fixed before you see them."), |
| ("🚀", "green", "Ghost Deploy", "One-click publish to HF Spaces with instant live URL."), |
| ] |
| for icon, color, ftitle, desc in default_features: |
| features_html += self.painter.LG_COMPONENTS["feature_card"].format( |
| ICON=icon, COLOR=color, TITLE=ftitle, DESCRIPTION=desc) |
|
|
| hero_subtitle = "Built with Omni-Vibe Studio — specialized AI swarm with zero-config database, Google OAuth, and Liquid Glass design." |
|
|
| auth_section = "" |
| if has_auth: |
| auth_section = """ |
| <section id="cta-section" class="glass" style="max-width:500px;margin:3rem auto;padding:2.5rem;text-align:center"> |
| <h3 class="gradient-text" style="font-size:1.5rem;margin-bottom:1rem">Get Started</h3> |
| <p style="color:var(--text2);margin-bottom:1.5rem">Sign in with Google — no password required.</p> |
| <button id="google-auth-btn" class="btn" style="width:100%;justify-content:center"> |
| <svg width="20" height="20" viewBox="0 0 24 24"><path fill="currentColor" d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92a5.06 5.06 0 01-2.2 3.32v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.1z"/><path fill="currentColor" d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"/><path fill="currentColor" d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"/><path fill="currentColor" d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"/></svg> |
| Sign in with Google |
| </button> |
| </section>""" |
|
|
| return f"""<!DOCTYPE html> |
| <html lang="en"> |
| <head> |
| <meta charset="UTF-8"> |
| <meta name="viewport" content="width=device-width,initial-scale=1.0"> |
| <title>{title}</title> |
| <style> |
| /* Omni-Vibe Liquid Glass Design System */ |
| {LIQUID_GLASS_CSS.strip()} |
| </style> |
| </head> |
| <body> |
| |
| <!-- Liquid Glass Wizard Logo --> |
| <div style="position:fixed;top:20px;left:50%;transform:translateX(-50%);z-index:100"> |
| {LIQUID_GLASS_LOGO} |
| </div> |
| |
| <!-- Navbar --> |
| <nav class="glass" style="padding:1rem 2rem;display:flex;align-items:center;justify-content:space-between;margin:0 1rem"> |
| <div style="display:flex;align-items:center;gap:.75rem"> |
| {LIQUID_GLASS_LOGO.replace('width="48"','width="32"').replace('height="48"','height="32"')} |
| <span class="gradient-text" style="font-weight:700;font-size:1.1rem">{title}</span> |
| </div> |
| <div style="display:flex;gap:1rem"> |
| {'''<button id="google-auth-btn" class="btn" style="padding:.5rem 1.25rem;font-size:.85rem">Sign In</button>''' if has_auth else '<button class="btn btn-outline" style="padding:.5rem 1.25rem;font-size:.85rem">Documentation</button>'} |
| </div> |
| </nav> |
| |
| <!-- Hero --> |
| <section style="display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:80vh;padding:2rem;text-align:center;margin-top:-60px"> |
| <h1 class="gradient-text" style="font-size:clamp(2.5rem,8vw,5rem);font-weight:800;line-height:1.1">{title}</h1> |
| <p style="font-size:1.25rem;color:var(--text2);margin-top:1.5rem;max-width:600px">{hero_subtitle}</p> |
| <div style="display:flex;gap:1rem;margin-top:2.5rem"> |
| <button class="btn">Get Started</button> |
| <button class="btn btn-outline">Learn More</button> |
| </div> |
| </section> |
| |
| <!-- Features --> |
| <section style="display:grid;grid-template-columns:repeat(auto-fit,minmax(280px,1fr));gap:1.5rem;padding:3rem 2rem;max-width:1200px;margin:0 auto"> |
| {features_html} |
| </section> |
| |
| {auth_section} |
| |
| <!-- Footer --> |
| <footer class="glass" style="margin-top:3rem;padding:2rem;text-align:center;color:var(--text3);font-size:.85rem"> |
| <p>Built with <span class="gradient-text" style="font-weight:600">Omni-Vibe Studio</span> — Liquid Glass Design System</p> |
| <p style="margin-top:.5rem">Zero-config · Google OAuth · SQLite · Ghost Deploy · Pinggy</p> |
| </footer> |
| |
| {f'''<script> |
| {GOOGLE_OAUTH_JS.strip()} |
| </script>''' if has_auth else ''} |
| |
| <script> |
| // Wizard hat pulse animation |
| const hat = document.querySelector('#wizard-hat'); |
| if (hat) {{ |
| let p = 0; |
| function animate() {{ |
| p += 0.02; |
| hat.style.transform = `scale(${{1 + Math.sin(p) * 0.06}})`; |
| hat.style.filter = `drop-shadow(0 0 ${{18 + Math.sin(p * 1.5) * 8}}px rgba(139,92,246,.6))`; |
| requestAnimationFrame(animate); |
| }} |
| animate(); |
| }} |
| </script> |
| |
| </body> |
| </html>""" |
|
|
|
|
| |
| |
| |
|
|
| class ReflectSelect: |
| """Sub-second Reflect-Select using compiled regex patterns.""" |
| VOID = PoseAuditor.SVG_VOID |
| PATTERNS = [ |
| (re.compile(r"console\.loge\("), "console.log("), |
| (re.compile(r"docment\."), "document."), |
| (re.compile(r"getElementbyId"), "getElementById"), |
| (re.compile(r"innerHtml"), "innerHTML"), |
| (re.compile(r"functon\s"), "function "), |
| (re.compile(r"retrun"), "return"), |
| ] |
|
|
| def heal(self, code: str, errors: List[str] = None) -> Tuple[str, int, int]: |
| errors_list = self._detect(code) |
| if errors: errors_list.extend(errors) |
| errors_list = list(set(errors_list)) |
| found = len(errors_list) |
| if not found: return code, 0, 0 |
| fixed = 0 |
| for i in range(15): |
| if not errors_list: break |
| code = self._apply_fixes(code, errors_list) |
| fixed += 1 |
| errors_list = self._detect(code) |
| return code, found, fixed |
|
|
| def _detect(self, code: str) -> List[str]: |
| e = [] |
| |
| if "<html" in code.lower() or code.startswith("<!"): |
| stack = [] |
| for m in re.finditer(r'<(?P<closing>/)?(?P<tag>\w+)(?:\s[^>]*?)?(?P<self>/)?>', code, re.IGNORECASE): |
| t = m.group('tag').lower() |
| if t in self.VOID: continue |
| if m.group('self'): continue |
| if m.group('closing'): |
| if stack and stack[-1]==t: stack.pop() |
| else: e.append(f"Unmatched </{t}>") |
| else: stack.append(t) |
| for t in stack: e.append(f"Unclosed <{t}>") |
| |
| 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 _apply_fixes(self, code: str, errors: List[str]) -> str: |
| for pat, rep in self.PATTERNS: |
| code = pat.sub(rep, code) |
| |
| for tag in re.findall(r'Unclosed <(\w+)>', '\n'.join(errors)): |
| if tag.lower() not in self.VOID: |
| close = code.lower().rfind('</body>') or code.lower().rfind('</html>') |
| if close >= 0: |
| code = code[:close] + f'</{tag}>\n' + code[close:] |
| return code |
|
|
| def validate(self, code: str) -> Dict: |
| e = self._detect(code) |
| return {"success": len(e)==0, "errors": e} |
|
|
|
|
| |
| |
| |
|
|
| @dataclass |
| class State: |
| engine: OmniVibeEngine = field(default_factory=OmniVibeEngine) |
| reflect: ReflectSelect = field(default_factory=ReflectSelect) |
| sessions: Dict = field(default_factory=dict) |
| codes: Dict = field(default_factory=dict) |
| sandbox: Dict = field(default_factory=dict) |
| publish_ready: Dict = field(default_factory=dict) |
|
|
| state = State() |
|
|
|
|
| |
| |
| |
|
|
| |
| class Orchestrator: |
| """Backward-compatible wrapper around OmniVibeEngine.""" |
| def pose(self, prompt: str) -> Dict: |
| plan = state.engine.pose(prompt) |
| return { |
| "model": "omni-vibe-swarm", |
| "domain": plan["architect"]["stack"]["backend"] and "fullstack" or "frontend", |
| "plan": plan, |
| } |
| def generate(self, prompt: str): |
| code, schema = state.engine.generate(prompt) |
| |
| chunk_size = max(1, len(code) // 20) |
| for i in range(0, len(code), chunk_size): |
| yield code[i:i+chunk_size] |
| time.sleep(0.02) |
| state.codes["_last_schema"] = schema |
|
|
| def sandbox_validate(code: str) -> Dict: |
| return state.reflect.validate(code) |
|
|
| print("🧙♂️ Omni-Vibe Core — Swarm Synchronized") |
| print(" Pose Architect: full-stack + zero-DB + Google OAuth") |
| print(" Pose Painter: Liquid Glass design system") |
| print(" Pose Auditor: step-by-step verification") |
| print(" Athanor ready — Steady Gold") |
|
|
