Update app.py

app.py

@@ -1,214 +1,159 @@
 import gradio as gr
-import uuid
-import json
 import boto3
-import re
+import json
 
 # -----------------------------
-# HELPERS
+# AWS BEDROCK SETUP
 # -----------------------------
 
-def create_block(block_type):
-    return {
-        "id": str(uuid.uuid4())[:6],
-        "type": block_type,
-        "title": block_type.upper(),
-        "var": f"{block_type}_{str(uuid.uuid4())[:4]}",
-        "value": "",
-        "prompt": "",
-        "system": "",
-        "output": ""
-    }
-
-def resolve_vars(text, variables):
-    return re.sub(
-        r"\{\{(\w+)\}\}",
-        lambda m: variables.get(m.group(1), m.group(0)),
-        text or ""
-    )
+bedrock = boto3.client(
+    service_name="bedrock-runtime",
+    region_name="us-east-1"  # change if needed
+)
 
-# -----------------------------
-# AI CALL
-# -----------------------------
+MODEL_ID = "anthropic.claude-3-5-sonnet-20240620-v1:0"
 
-def call_claude(prompt, system):
-    client = boto3.client("bedrock-runtime", region_name="us-east-1")
 
-    body = json.dumps({
-        "max_tokens": 1000,
-        "system": system,
-        "messages": [{"role": "user", "content": prompt}]
-    })
+def call_llm(prompt):
+    try:
+        body = json.dumps({
+            "anthropic_version": "bedrock-2023-05-31",
+            "messages": [
+                {"role": "user", "content": prompt}
+            ],
+            "max_tokens": 500,
+            "temperature": 0.7
+        })
 
-    response = client.invoke_model(
-        modelId="anthropic.claude-3-sonnet-20240229-v1:0",
-        body=body
-    )
+        response = bedrock.invoke_model(
+            body=body,
+            modelId=MODEL_ID,
+            contentType="application/json"
+        )
+
+        response_body = json.loads(response["body"].read())
+
+        return response_body["content"][0]["text"]
+
+    except Exception as e:
+        return f"ERROR: {str(e)}"
 
-    result = json.loads(response["body"].read())
-    return result["content"][0]["text"]
 
 # -----------------------------
-# ENGINE
+# BLOCK LOGIC
 # -----------------------------
 
-def run_flow(blocks):
-    variables = {}
-    logs = []
+def create_blocks(text):
+    lines = [line.strip() for line in text.split("\n") if line.strip()]
+    if not lines:
+        lines = ["EMPTY"]
 
-    for b in blocks:
-        try:
-            if b["type"] == "text":
-                variables[b["var"]] = b["value"]
+    blocks = [f"{i}: {line}" for i, line in enumerate(lines)]
+    return blocks, gr.update(choices=blocks, value=blocks[0])
 
-            elif b["type"] == "ai":
-                prompt = resolve_vars(b["prompt"], variables)
-                system = b["system"] or "You are helpful"
 
-                output = call_claude(prompt, system)
-                b["output"] = output
-                variables[b["var"]] = output
+def select_block(blocks, selected):
+    if not blocks or not selected:
+        return ""
 
-                logs.append(f"✅ {b['title']} executed")
+    idx = int(selected.split(":")[0])
+    return blocks[idx].split(": ", 1)[1]
 
-        except Exception as e:
-            logs.append(f"❌ {b['title']} failed: {str(e)}")
 
-    return blocks, variables, "\n".join(logs)
+def update_block(blocks, selected, new_text):
+    if not blocks or not selected:
+        return blocks, gr.update()
 
-# -----------------------------
-# ACTIONS
-# -----------------------------
+    idx = int(selected.split(":")[0])
+    blocks[idx] = f"{idx}: {new_text}"
 
-def refresh_choices(blocks):
-    return [f"{i}: {b['title']}" for i, b in enumerate(blocks)]
+    return blocks, gr.update(choices=blocks, value=blocks[idx])
 
-def add_block(blocks, block_type):
-    blocks.append(create_block(block_type))
 
-    choices = refresh_choices(blocks)
-    selected = choices[-1] if choices else None
+def ai_rewrite(blocks, selected):
+    if not blocks or not selected:
+        return blocks, gr.update()
 
-    return blocks, choices, selected
+    idx = int(selected.split(":")[0])
+    original = blocks[idx].split(": ", 1)[1]
 
-def load_block(blocks, selected):
-    if not selected:
-        return "", "", "", "", ""
+    prompt = f"Rewrite this more clearly and professionally:\n\n{original}"
 
-    idx = int(selected.split(":")[0])
-    b = blocks[idx]
+    new_text = call_llm(prompt)
+
+    blocks[idx] = f"{idx}: {new_text}"
 
-    return b["var"], b["value"], b["prompt"], b["system"], b["output"]
+    return blocks, gr.update(choices=blocks, value=blocks[idx])
 
-def save_block(blocks, selected, var, value, prompt, system):
-    if not selected:
-        return blocks
+
+def ai_summarize(blocks, selected):
+    if not blocks or not selected:
+        return ""
 
     idx = int(selected.split(":")[0])
+    text = blocks[idx].split(": ", 1)[1]
+
+    prompt = f"Summarize this in 1 sentence:\n\n{text}"
 
-    blocks[idx].update({
-        "var": var,
-        "value": value,
-        "prompt": prompt,
-        "system": system
-    })
+    return call_llm(prompt)
 
-    return blocks
 
 # -----------------------------
 # UI
 # -----------------------------
 
-with gr.Blocks() as demo:
+with gr.Blocks(title="Blocksmith + Bedrock") as app:
 
-    blocks_state = gr.State([])
+    gr.Markdown("# 🧱 Blocksmith (AI Powered via Bedrock)")
 
-    gr.Markdown("# ⚡ Blocksmith AI")
+    state_blocks = gr.State([])
 
-    with gr.Row():
+    input_text = gr.Textbox(label="Paste Text", lines=8)
+    create_btn = gr.Button("Create Blocks")
 
-        # SIDEBAR
-        with gr.Column(scale=1):
-            gr.Markdown("## 🧩 Blocks")
-            add_text = gr.Button("➕ Text Input")
-            add_ai = gr.Button("➕ AI Block")
-
-        # CANVAS (Dropdown instead of Radio)
-        with gr.Column(scale=2):
-            gr.Markdown("## 🧠 Canvas")
-
-            block_selector = gr.Dropdown(
-                choices=[],
-                value=None,
-                label="Select Block"
-            )
-
-        # INSPECTOR
-        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 Prompt")
-            output = gr.Textbox(label="Output", interactive=False)
-
-    # RUN
-    run_btn = gr.Button("▶ Run Flow")
-    variables_out = gr.JSON(label="Variables")
-    logs = gr.Textbox(label="Logs")
-
-    # ---------------- EVENTS ----------------
-
-    add_text.click(
-        fn=lambda b: add_block(b, "text"),
-        inputs=blocks_state,
-        outputs=[blocks_state, block_selector, block_selector]
-    )
+    block_selector = gr.Dropdown(choices=[], label="Blocks", interactive=True)
 
-    add_ai.click(
-        fn=lambda b: add_block(b, "ai"),
-        inputs=blocks_state,
-        outputs=[blocks_state, block_selector, block_selector]
-    )
+    block_editor = gr.Textbox(label="Edit Block")
 
-    block_selector.change(
-        fn=load_block,
-        inputs=[blocks_state, block_selector],
-        outputs=[var, value, prompt, system, output]
-    )
+    with gr.Row():
+        update_btn = gr.Button("Update")
+        rewrite_btn = gr.Button("✨ Rewrite (AI)")
+        summarize_btn = gr.Button("🧠 Summarize")
 
-    var.change(
-        fn=save_block,
-        inputs=[blocks_state, block_selector, var, value, prompt, system],
-        outputs=blocks_state
+    summary_output = gr.Textbox(label="Summary")
+
+    # -----------------------------
+    # EVENTS
+    # -----------------------------
+
+    create_btn.click(
+        fn=create_blocks,
+        inputs=input_text,
+        outputs=[state_blocks, block_selector]
     )
 
-    value.change(
-        fn=save_block,
-        inputs=[blocks_state, block_selector, var, value, prompt, system],
-        outputs=blocks_state
+    block_selector.change(
+        fn=select_block,
+        inputs=[state_blocks, block_selector],
+        outputs=block_editor
     )
 
-    prompt.change(
-        fn=save_block,
-        inputs=[blocks_state, block_selector, var, value, prompt, system],
-        outputs=blocks_state
+    update_btn.click(
+        fn=update_block,
+        inputs=[state_blocks, block_selector, block_editor],
+        outputs=[state_blocks, block_selector]
     )
 
-    system.change(
-        fn=save_block,
-        inputs=[blocks_state, block_selector, var, value, prompt, system],
-        outputs=blocks_state
+    rewrite_btn.click(
+        fn=ai_rewrite,
+        inputs=[state_blocks, block_selector],
+        outputs=[state_blocks, block_selector]
     )
 
-    run_btn.click(
-        fn=run_flow,
-        inputs=blocks_state,
-        outputs=[blocks_state, variables_out, logs]
+    summarize_btn.click(
+        fn=ai_summarize,
+        inputs=[state_blocks, block_selector],
+        outputs=summary_output
     )
 
-# CSS fix
-demo.launch(css="""
-body { background-color: #0f172a; color: white; }
-""")
+app.launch()