Update app.py

app.py

@@ -1,34 +1,27 @@
 import gradio as gr
+import uuid
 import json
 import boto3
-import uuid
 import re
 
 # -----------------------------
-# GLOBAL STATE HELPERS
+# STATE HELPERS
 # -----------------------------
 
-def new_block(block_type):
+def create_block(block_type):
     return {
-        "id": str(uuid.uuid4())[:8],
+        "id": str(uuid.uuid4())[:6],
         "type": block_type,
-        "var": f"{block_type}_{str(uuid.uuid4())[:4]}",
         "title": block_type.upper(),
+        "var": f"{block_type}_{str(uuid.uuid4())[:4]}",
         "value": "",
         "prompt": "",
         "system": "",
-        "output": "",
-        "options": [],
-        "min": 0,
-        "max": 100,
-        "step": 1,
+        "output": ""
     }
 
 def resolve_vars(text, variables):
-    def repl(match):
-        key = match.group(1)
-        return variables.get(key, f"{{{{{key}}}}}")
-    return re.sub(r"\{\{(\w+)\}\}", repl, text or "")
+    return re.sub(r"\{\{(\w+)\}\}", lambda m: variables.get(m.group(1), m.group(0)), text or "")
 
 # -----------------------------
 # AI CALL
@@ -52,110 +45,146 @@ def call_claude(prompt, system):
     return result["content"][0]["text"]
 
 # -----------------------------
-# BLOCK EXECUTION ENGINE
+# CORE ENGINE
 # -----------------------------
 
-def run_blocks(blocks):
+def run_flow(blocks):
     variables = {}
     logs = []
 
     for b in blocks:
         try:
-            if b["type"] == "text-input":
-                variables[b["var"]] = b["value"]
-
-            elif b["type"] == "select-input":
+            if b["type"] == "text":
                 variables[b["var"]] = b["value"]
 
-            elif b["type"] == "slider-input":
-                variables[b["var"]] = str(b["value"])
-
-            elif b["type"] in ["ai-text", "ai-transform"]:
+            elif b["type"] == "ai":
                 prompt = resolve_vars(b["prompt"], variables)
-                system = b["system"] or "You are a helpful assistant."
-                output = call_claude(prompt, system)
+                system = b["system"] or "You are helpful"
 
+                output = call_claude(prompt, system)
                 b["output"] = output
                 variables[b["var"]] = output
-                logs.append(f"✅ {b['title']} ran")
 
-            elif b["type"] == "display":
-                ref = b.get("ref")
-                b["output"] = variables.get(ref, "")
+                logs.append(f"✅ {b['title']} executed")
 
         except Exception as e:
             logs.append(f"❌ {b['title']} failed: {str(e)}")
-            b["output"] = f"Error: {str(e)}"
 
     return blocks, variables, "\n".join(logs)
 
 # -----------------------------
-# UI HELPERS
+# UI ACTIONS
 # -----------------------------
 
 def add_block(blocks, block_type):
-    blocks.append(new_block(block_type))
+    blocks.append(create_block(block_type))
     return blocks, blocks
 
-def update_block(blocks, idx, field, value):
-    blocks[idx][field] = value
-    return blocks
-
-# -----------------------------
-# UI RENDERER
-# -----------------------------
-
-def render_blocks(blocks):
-    ui = []
-
-    for i, b in enumerate(blocks):
-        with gr.Group():
-            gr.Markdown(f"### {b['title']} ({b['type']})")
-
-            var = gr.Textbox(value=b["var"], label="Variable")
-            val = gr.Textbox(value=b["value"], label="Value")
-
-            prompt = gr.Textbox(value=b["prompt"], label="Prompt")
-            system = gr.Textbox(value=b["system"], label="System Prompt")
-
-            out = gr.Textbox(value=b.get("output", ""), label="Output")
+def select_block(blocks, idx):
+    return blocks, idx, blocks[idx]
 
-            var.change(lambda v, blocks=blocks, i=i: update_block(blocks, i, "var", v), var, None)
-            val.change(lambda v, blocks=blocks, i=i: update_block(blocks, i, "value", v), val, None)
-            prompt.change(lambda v, blocks=blocks, i=i: update_block(blocks, i, "prompt", v), prompt, None)
-            system.change(lambda v, blocks=blocks, i=i: update_block(blocks, i, "system", v), system, None)
-
-        ui.append(gr.Markdown("---"))
-
-    return ui
+def update_block(blocks, idx, data):
+    blocks[idx].update(data)
+    return blocks
 
 # -----------------------------
 # MAIN UI
 # -----------------------------
 
-with gr.Blocks(title="Blocksmith AI") as demo:
+with gr.Blocks(css="""
+body {background-color: #0f172a; color: white;}
+""") as demo:
 
     blocks_state = gr.State([])
+    selected_idx = gr.State(None)
 
-    gr.Markdown("# ⚡ Blocksmith (Gradio Version)")
+    gr.Markdown("# ⚡ Blocksmith AI")
 
     with gr.Row():
-        add_text = gr.Button("➕ Text Input")
-        add_ai = gr.Button("➕ AI Generate")
-        add_display = gr.Button("➕ Display")
-
-    blocks_ui = gr.Column()
-
-    run_btn = gr.Button("▶ Run All")
-    output_vars = gr.JSON(label="Variables")
-    logs = gr.Textbox(label="Run Logs")
-
-    # ADD BLOCKS
-    add_text.click(lambda b: add_block(b, "text-input"), blocks_state, [blocks_state, blocks_ui])
-    add_ai.click(lambda b: add_block(b, "ai-text"), blocks_state, [blocks_state, blocks_ui])
-    add_display.click(lambda b: add_block(b, "display"), blocks_state, [blocks_state, blocks_ui])
 
-    # RUN
-    run_btn.click(run_blocks, blocks_state, [blocks_state, output_vars, logs])
+        # -----------------------------
+        # 🧱 SIDEBAR
+        # -----------------------------
+        with gr.Column(scale=1):
+            gr.Markdown("## 🧩 Blocks")
+
+            add_text = gr.Button("➕ Text Input")
+            add_ai = gr.Button("➕ AI Block")
+
+        # -----------------------------
+        # 🎨 CANVAS
+        # -----------------------------
+        with gr.Column(scale=2):
+            gr.Markdown("## 🧠 Canvas")
+
+            block_list = gr.Radio(
+                choices=[],
+                label="Blocks",
+                interactive=True
+            )
+
+        # -----------------------------
+        # ⚙️ INSPECTOR PANEL
+        # -----------------------------
+        with gr.Column(scale=2):
+            gr.Markdown("## ⚙️ Inspector")
+
+            var = gr.Textbox(label="Variable")
+            value = gr.Textbox(label="Value")
+            prompt = gr.Textbox(label="Prompt")
+            system = gr.Textbox(label="System")
+            output = gr.Textbox(label="Output", interactive=False)
+
+    # -----------------------------
+    # ▶ RUN + LOGS
+    # -----------------------------
+    run_btn = gr.Button("▶ Run Flow")
+
+    variables_out = gr.JSON(label="Variables")
+    logs = gr.Textbox(label="Logs")
+
+    # -----------------------------
+    # EVENTS
+    # -----------------------------
+
+    # Add blocks
+    add_text.click(lambda b: add_block(b, "text"), blocks_state, [blocks_state, block_list])
+    add_ai.click(lambda b: add_block(b, "ai"), blocks_state, [blocks_state, block_list])
+
+    # Update block list display
+    def refresh_list(blocks):
+        return [f"{i}: {b['title']}" for i, b in enumerate(blocks)]
+
+    blocks_state.change(refresh_list, blocks_state, block_list)
+
+    # Select block
+    def load_block(blocks, idx):
+        if idx is None:
+            return "", "", "", "", ""
+        b = blocks[int(idx.split(":")[0])]
+        return b["var"], b["value"], b["prompt"], b["system"], b["output"]
+
+    block_list.change(load_block, [blocks_state, block_list], [var, value, prompt, system, output])
+
+    # Update block fields
+    def save_block(blocks, idx, v, val, p, s):
+        if idx is None:
+            return blocks
+        i = int(idx.split(":")[0])
+        blocks[i].update({
+            "var": v,
+            "value": val,
+            "prompt": p,
+            "system": s
+        })
+        return blocks
+
+    var.change(save_block, [blocks_state, block_list, var, value, prompt, system], blocks_state)
+    value.change(save_block, [blocks_state, block_list, var, value, prompt, system], blocks_state)
+    prompt.change(save_block, [blocks_state, block_list, var, value, prompt, system], blocks_state)
+    system.change(save_block, [blocks_state, block_list, var, value, prompt, system], blocks_state)
+
+    # Run flow
+    run_btn.click(run_flow, blocks_state, [blocks_state, variables_out, logs])
 
 demo.launch()