Update theme/app.py

theme/app.py

@@ -2,19 +2,23 @@ import os
 import uuid
 import json
 import time
+import requests
 from pathlib import Path
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse, HTMLResponse
 from fastapi.templating import Jinja2Templates
 
 # =========================
-# CORE APP
+# APP CORE
 # =========================
 
-app = FastAPI(title="PyRunner PAO v4 Distributed OS", version="4.0")
+app = FastAPI(title="PyRunner PAO v5 SaaS Core", version="5.0")
 
 BASE_DIR = Path(__file__).resolve().parent
-templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+
+# SAFE TEMPLATE LOADING (prevents your Jinja crash)
+TEMPLATE_DIR = BASE_DIR / "templates"
+templates = Jinja2Templates(directory=str(TEMPLATE_DIR))
 
 # =========================
 # CONFIG
@@ -30,146 +34,152 @@ MODELS = {
 }
 
 # =========================
-# MEMORY GRAPH (NOW EVENT-SAFE)
+# MEMORY SYSTEM (replace later with Supabase/Postgres)
 # =========================
 
-MEMORY_DB = {
-    "nodes": {},
-    "edges": []
-}
+MEMORY = {}
 
 def memory_store(task_id, data):
-    MEMORY_DB["nodes"][task_id] = data
+    MEMORY[task_id] = data
 
-def memory_query(keyword):
-    results = []
-    for k, v in MEMORY_DB["nodes"].items():
-        if keyword.lower() in v.get("task", "").lower():
-            results.append(v)
-    return results
+def memory_get(task_id):
+    return MEMORY.get(task_id, {})
 
 # =========================
-# EVENT BUS (SIMULATED QUEUE)
+# EVENT SYSTEM (lightweight observability)
 # =========================
 
-EVENT_QUEUE = []
+EVENTS = []
 
-def emit_event(event_type, payload):
-    EVENT_QUEUE.append({
+def emit(event_type, payload):
+    EVENTS.append({
         "id": str(uuid.uuid4()),
         "type": event_type,
         "payload": payload,
-        "timestamp": time.time()
+        "ts": time.time()
     })
 
-def consume_events():
-    events = EVENT_QUEUE[:]
-    EVENT_QUEUE.clear()
-    return events
+def drain_events():
+    data = EVENTS[:]
+    EVENTS.clear()
+    return data
 
 # =========================
-# MODEL CALL
+# LLM CALL
 # =========================
 
-def call_model(prompt, model):
-    import requests
+def call_llm(prompt, model):
     try:
         r = requests.post(
             f"{OLLAMA_URL}/api/generate",
-            json={"model": model, "prompt": prompt, "stream": False},
+            json={
+                "model": model,
+                "prompt": prompt,
+                "stream": False
+            },
             timeout=120
         )
         return r.json().get("response", "")
     except Exception as e:
-        return f"ERROR: {str(e)}"
+        return f"LLM_ERROR: {str(e)}"
 
 # =========================
-# ORCHESTRATOR (DAG BUILDER)
+# DAG PLANNER (FIXED JSON SAFETY)
 # =========================
 
-def orchestrator(task):
+def plan_task(task: str):
 
     prompt = f"""
-Break into structured execution DAG:
+Return ONLY valid JSON.
+
+Break task into steps:
 
 Task: {task}
 
-Return JSON array like:
+Format:
 [
-  {{"step": "..." }},
-  {{"step": "..."}}
+  "step 1",
+  "step 2",
+  "step 3"
 ]
 """
 
-    raw = call_model(prompt, MODELS["planner"])
+    raw = call_llm(prompt, MODELS["planner"])
 
     try:
-        return json.loads(raw)
-    except:
-        # fallback
-        return [{"step": task}]
-
-# =========================
-# WORKER (STATELESS EXECUTOR)
-# =========================
-
-def worker(step, context=""):
+        steps = json.loads(raw)
 
-    prompt = f"""
-Execute this step:
-
-{step}
+        # ensure list safety
+        if isinstance(steps, list):
+            return [{"step": s} for s in steps]
 
-Context:
-{context}
-"""
+    except:
+        pass
 
-    return call_model(prompt, MODELS["worker"])
+    # fallback (always safe)
+    return [{"step": task}]
 
 # =========================
 # TOOL SYSTEM
 # =========================
 
-def tool_calculator(expr):
+def tool_calculator(expr: str):
     try:
         return eval(expr, {"__builtins__": {}})
     except:
-        return "error"
+        return "calc_error"
 
 TOOLS = {
     "calculator": tool_calculator
 }
 
-def tool_router(text):
-
+def run_tools(text: str):
     if "calc:" in text:
         expr = text.replace("calc:", "").strip()
-        return TOOLS["calculator"](expr)
-
+        return str(TOOLS["calculator"](expr))
     return text
 
 # =========================
-# CRITIC (QUALITY GATE)
+# WORKER NODE
+# =========================
+
+def worker(step: str, context: str):
+
+    prompt = f"""
+Execute this instruction clearly:
+
+Step: {step}
+
+Context:
+{context}
+"""
+
+    return call_llm(prompt, MODELS["worker"])
+
+# =========================
+# CRITIC (QUALITY CHECK)
 # =========================
 
 def critic(task, output):
 
     prompt = f"""
-Score 0-10 and improve suggestion:
+Rate and improve:
 
 Task: {task}
 Output: {output}
+
+Return short improvement suggestion.
 """
 
-    return call_model(prompt, MODELS["critic"])
+    return call_llm(prompt, MODELS["critic"])
 
 # =========================
 # SYNTHESIZER
 # =========================
 
-def synthesize(results):
+def synth(outputs):
 
-    combined = "\n".join(results)
+    combined = "\n".join(outputs)
 
     prompt = f"""
 Create final clean response:
@@ -177,41 +187,44 @@ Create final clean response:
 {combined}
 """
 
-    return call_model(prompt, MODELS["synth"])
+    return call_llm(prompt, MODELS["synth"])
 
 # =========================
-# DISTRIBUTED EXECUTION ENGINE
+# EXECUTION ENGINE
 # =========================
 
-def execute_dag(task, dag):
+def run_dag(task: str):
 
     task_id = str(uuid.uuid4())
 
-    emit_event("task_started", {"task_id": task_id, "task": task})
+    emit("task_started", {"task_id": task_id, "task": task})
 
+    dag = plan_task(task)
     results = []
 
-    for node in dag:
+    context = task
 
-        step = node.get("step")
+    for node in dag:
 
-        emit_event("step_started", {"step": step})
+        step = node["step"]
 
-        raw = worker(step)
+        emit("step_started", {"step": step})
 
-        processed = tool_router(raw)
+        raw = worker(step, context)
+        processed = run_tools(raw)
 
-        crit = critic(task, processed)
+        _crit = critic(task, processed)
 
         results.append(processed)
+        context = processed
 
-        emit_event("step_completed", {
+        emit("step_done", {
             "step": step,
             "output": processed,
-            "critique": crit
+            "critique": _crit
         })
 
-    final = synthesize(results)
+    final = synth(results)
 
     memory_store(task_id, {
         "task": task,
@@ -219,32 +232,37 @@ def execute_dag(task, dag):
         "steps": results
     })
 
-    emit_event("task_completed", {"task_id": task_id})
+    emit("task_done", {"task_id": task_id})
 
     return {
         "task_id": task_id,
         "dag": dag,
-        "events": consume_events(),
+        "events": drain_events(),
         "final": final
     }
 
 # =========================
-# MAIN ORCHESTRATION PIPELINE
+# API ROUTES
 # =========================
 
-def run_pao(task):
+@app.get("/", response_class=HTMLResponse)
+async def home(request: Request):
+
+    # SAFE CHECK: prevents template crash
+    if not (TEMPLATE_DIR / "index.html").exists():
+        return HTMLResponse("<h1>Missing index.html</h1>", status_code=500)
 
-    dag = orchestrator(task)
+    return templates.TemplateResponse("index.html", {"request": request})
 
-    return execute_dag(task, dag)
 
-# =========================
-# API
-# =========================
+@app.get("/builder", response_class=HTMLResponse)
+async def builder(request: Request):
+
+    if not (TEMPLATE_DIR / "builder.html").exists():
+        return HTMLResponse("<h1>Missing builder.html</h1>", status_code=500)
+
+    return templates.TemplateResponse("builder.html", {"request": request})
 
-@app.get("/", response_class=HTMLResponse)
-async def home(request: Request):
-    return templates.TemplateResponse("index.html", {"request": request})
 
 @app.post("/api/run")
 async def run(request: Request):
@@ -255,12 +273,14 @@ async def run(request: Request):
     if not task:
         return JSONResponse({"error": "missing task"}, status_code=400)
 
-    return run_pao(task)
+    return run_dag(task)
+
 
 @app.get("/api/memory/{task_id}")
 def get_memory(task_id: str):
-    return MEMORY_DB["nodes"].get(task_id, {})
+    return memory_get(task_id)
+
 
 @app.get("/api/events")
 def get_events():
-    return {"events": EVENT_QUEUE}
+    return {"events": EVENTS}