Spaces:

mgbam
/

yeyefowl

Running

App Files Files Community

mgbam commited on about 8 hours ago

Commit

586415b

verified ·

1 Parent(s): 449064c

Create app.py

Browse files

Files changed (1) hide show

app.py +232 -0

app.py ADDED Viewed

	@@ -0,0 +1,232 @@

+import os
+import json
+from typing import Dict, List, Optional
+import base64
+from PIL import Image
+import PyPDF2
+import docx
+import pytesseract
+import gradio as gr
+from huggingface_hub import InferenceClient
+import zipfile
+import io
+import time
+import asyncio
+import plotly.graph_objects as go
+import networkx as nx
+# --- Synapsera X: The Cognitive Operating System ---
+# --- Multi-Agent Prompt Engineering ---
+# Each prompt now defines a specialized agent's role and output format.
+SYNTHESIS_AGENT_PROMPT = """
+You are the **Synthesis Agent** of the Synapsera OS. Your task is to analyze the user's raw input and create the initial **Semantic Thought Graph**. Your output must be ONLY a single, valid JSON object with 'summary', 'nodes', and 'edges'. This graph is the foundational artifact for all other agents.
+"""
+CRITIC_AGENT_PROMPT = """
+You are **THE CRITIC**, a member of the Synapsera Cognitive Council. You are ruthless, logical, and skeptical. Your task is to analyze the provided Thought Graph. Identify every logical fallacy, weak assumption, cognitive bias, and potential point of failure. Output your analysis as a concise, hard-hitting Markdown report. Do not be polite.
+"""
+VISIONARY_AGENT_PROMPT = """
+You are **THE VISIONARY**, a member of the Synapsera Cognitive Council. You are creative, expansive, and forward-thinking. Your task is to analyze the provided Thought Graph. Identify emergent patterns, latent potential, and high-impact 'what if' scenarios. Extrapolate the user's ideas into the most ambitious, world-changing version possible. Output your analysis as an inspiring and expansive Markdown report.
+"""
+PRAGMATIST_AGENT_PROMPT = """
+You are **THE PRAGMATIST**, a member of the Synapsera Cognitive Council. You are grounded, practical, and action-oriented. Your task is to analyze the provided Thought Graph. Translate abstract concepts into a concrete plan. Identify the immediate next steps, required resources, and potential real-world obstacles. Output your analysis as a clear, actionable checklist in Markdown format.
+"""
+ARCHITECT_AGENT_PROMPT = """
+You are the **Architect Agent** of the Synapsera OS. Your task is to build a complete, functional, single-file web application based on the user's request. You must use Tailwind CSS via CDN and embed all JS in the HTML file. Your output must be ONLY the raw HTML code.
+"""
+REFACTOR_AGENT_PROMPT = """
+You are the **Architect Agent** performing a self-correction cycle. You will be given your own initial code and a critique from the Critic Agent. Your task is to rewrite the code to address the critique, improving its functionality, UX, and robustness. Your output must be ONLY the new, improved, raw HTML code.
+"""
+# --- Client Initialization ---
+HF_TOKEN = os.getenv('HF_TOKEN')
+client = InferenceClient(token=HF_TOKEN)
+MODEL_ID = "mistralai/Mixtral-8x22B-Instruct-v0.1"
+# --- Helper & Rendering Functions ---
+def create_zip_from_code(html_code: str, readme_text: str) -> Optional[str]:
+    # (Enhanced to create a full project structure)
+    if not html_code: return None
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+        # A more robust parser would be ideal, but regex is fine for this demo
+        import re
+        style_match = re.search(r'<style>(.*?)</style>', html_code, re.DOTALL)
+        script_match = re.search(r'<script>(.*?)</script>', html_code, re.DOTALL)
+        body_match = re.search(r'<body>(.*?)</body>', html_code, re.DOTALL)
+        html_content = f"<!DOCTYPE html>\n<html lang='en'>\n<head>\n    <meta charset='UTF-8'>\n    <meta name='viewport' content='width=device-width, initial-scale=1.0'>\n    <title>Synapsera-Built App</title>\n    <link href='style.css' rel='stylesheet'>\n</head>\n<body>\n{body_match.group(1) if body_match else ''}\n<script src='script.js'></script>\n</body>\n</html>"
+        css_content = style_match.group(1) if style_match else "/* CSS not found */"
+        js_content = script_match.group(1) if script_match else "// JS not found"
+        zf.writestr("index.html", html_content)
+        zf.writestr("style.css", css_content.strip())
+        zf.writestr("script.js", js_content.strip())
+        zf.writestr("README.md", readme_text)
+        # Add a placeholder Python backend
+        zf.writestr("server.py", "from flask import Flask\n\napp = Flask(__name__)\n\[email protected]('/')\ndef home():\n    return 'Synapsera-Built App Backend'\n\nif __name__ == '__main__':\n    app.run(debug=True, port=5000)\n")
+    zip_path = "/tmp/application_project.zip"
+    with open(zip_path, "wb") as f: f.write(zip_buffer.getvalue())
+    return zip_path
+def render_3d_graph(graph_data: Optional[Dict] = None):
+    # (This is the "wow" factor visualization)
+    if not graph_data or not graph_data.get('nodes'):
+        fig = go.Figure()
+        fig.update_layout(title_text="Cognitive Nebula Awaiting Synthesis...", template="plotly_dark", height=700)
+        return fig
+    G = nx.Graph()
+    for node in graph_data['nodes']: G.add_node(node['id'])
+    for edge in graph_data.get('edges', []):
+        if edge['source'] in G.nodes and edge['target'] in G.nodes:
+            G.add_edge(edge['source'], edge['target'])
+    pos = nx.spring_layout(G, dim=3, seed=42, iterations=50)
+    node_x, node_y, node_z = [pos[n][0] for n in G.nodes()], [pos[n][1] for n in G.nodes()], [pos[n][2] for n in G.nodes()]
+    edge_x, edge_y, edge_z = [], [], []
+    for edge in G.edges():
+        x0, y0, z0 = pos[edge[0]]
+        x1, y1, z1 = pos[edge[1]]
+        edge_x.extend([x0, x1, None])
+        edge_y.extend([y0, y1, None])
+        edge_z.extend([z0, z1, None])
+    color_map = {"Concept": "#8A2BE2", "Belief": "#2ca02c", "Assumption": "#ff7f0e"}
+    node_text = [f"<b>{n['label']}</b><br>({n['type']})" for n in graph_data['nodes']]
+    node_color = [color_map.get(n['type'], "#7f7f7f") for n in graph_data['nodes']]
+    node_size = [10 + n.get('importance', 0.5) * 15 for n in graph_data['nodes']]
+    edge_trace = go.Scatter3d(x=edge_x, y=edge_y, z=edge_z, mode='lines', line=dict(color='#888', width=2), hoverinfo='none')
+    node_trace = go.Scatter3d(x=node_x, y=node_y, z=node_z, mode='markers', text=node_text,
+                              marker=dict(color=node_color, size=node_size, symbol='circle'), hoverinfo='text')
+    fig = go.Figure(data=[edge_trace, node_trace])
+    fig.update_layout(title=f"Cognitive Nebula: {graph_data.get('summary', '')}", showlegend=False, template="plotly_dark", height=700,
+                      scene=dict(xaxis=dict(visible=False), yaxis=dict(visible=False), zaxis=dict(visible=False)))
+    return fig
+# --- Core Asynchronous Multi-Agent Logic ---
+async def run_agent(prompt: str, context: str) -> str:
+    """A generic function to run any agent asynchronously."""
+    messages = [{"role": "system", "content": prompt}, {"role": "user", "content": context}]
+    try:
+        # Using Hugging Face's async client would be ideal here if available,
+        # but we can wrap the sync call in an async function for now.
+        loop = asyncio.get_running_loop()
+        response = await loop.run_in_executor(
+            None,
+            lambda: client.chat_completion(model=MODEL_ID, messages=messages, max_tokens=4096)
+        )
+        return response.choices[0].message.content or "Agent returned an empty response."
+    except Exception as e:
+        return f"Agent Error: {e}"
+async def universal_synthesis(synthesis_mode: str, text_input: str, progress=gr.Progress(track_tqdm=True)):
+    """The main entry point that orchestrates the agent swarm."""
+    if synthesis_mode == "Analyze Thought":
+        yield "Initializing Synthesis Agent...", gr.update(), gr.update(), gr.update(), gr.update(visible=False)
+        graph_json_str = await run_agent(SYNTHESIS_AGENT_PROMPT, text_input)
+        try:
+            graph_data = json.loads(graph_json_str)
+            graph_context = f"Thought Graph:\n{json.dumps(graph_data, indent=2)}"
+        except json.JSONDecodeError:
+            yield f"Synthesis Agent failed to produce valid JSON.\n{graph_json_str}", gr.update(), gr.update(), gr.update(), gr.update(visible=False)
+            return
+        yield "Convening Cognitive Council...", render_3d_graph(graph_data), "", "", "", gr.update(visible=False)
+        # Run Critic, Visionary, and Pragmatist agents in parallel
+        critic_task = asyncio.create_task(run_agent(CRITIC_AGENT_PROMPT, graph_context))
+        visionary_task = asyncio.create_task(run_agent(VISIONARY_AGENT_PROMPT, graph_context))
+        pragmatist_task = asyncio.create_task(run_agent(PRAGMATIST_AGENT_PROMPT, graph_context))
+        # Stream results as they complete
+        critic_analysis = await critic_task
+        yield f"Convening Cognitive Council...\n\n**CRITIC ANALYSIS COMPLETE**", render_3d_graph(graph_data), critic_analysis, "", "", gr.update(visible=False)
+        visionary_analysis = await visionary_task
+        yield f"Convening Cognitive Council...\n\n**CRITIC & VISIONARY ANALYSIS COMPLETE**", render_3d_graph(graph_data), critic_analysis, visionary_analysis, "", gr.update(visible=False)
+        pragmatist_analysis = await pragmatist_task
+        yield f"**Cognitive Council Concluded.**", render_3d_graph(graph_data), critic_analysis, visionary_analysis, pragmatist_analysis, gr.update(visible=False)
+    else: # Build Application
+        yield "Initializing Architect Agent...", gr.update(), gr.update(visible=True, value=None), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+        initial_code = await run_agent(ARCHITECT_AGENT_PROMPT, text_input)
+        yield "Architect Agent completed initial build. Engaging Critic Agent for review...", gr.update(), gr.update(visible=True, value=initial_code), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+        critic_review_context = f"Please review this HTML code for bugs, UX flaws, and improvements:\n\n{initial_code}"
+        critic_review = await run_agent(CRITIC_AGENT_PROMPT, critic_review_context)
+        yield f"Critic Agent review complete. Initiating self-correction loop...\n\n**Critique:**\n{critic_review}", gr.update(), gr.update(visible=True, value=initial_code), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+        refactor_context = f"Here is the initial code:\n```html\n{initial_code}\n```\n\nHere is the critique:\n{critic_review}\n\nPlease provide the new, improved code."
+        refactored_code = await run_agent(REFACTOR_AGENT_PROMPT, refactor_context)
+        readme = f"# Synapsera-Built Application\n\nThis project was generated by the Synapsera X Cognitive OS.\n\n## User Prompt:\n{text_input}\n\n## Critic's Review of v1:\n{critic_review}"
+        zip_path = create_zip_from_code(refactored_code, readme)
+        yield "Self-correction complete. Final application generated.", gr.update(), gr.update(visible=False), gr.update(visible=True, value=initial_code), gr.update(visible=True, value=refactored_code), gr.update(visible=True, value=zip_path)
+# --- Gradio UI for Synapsera X ---
+with gr.Blocks(theme=gr.themes.Default(primary_hue="purple", secondary_hue="blue"), css="footer{display:none !important}") as demo:
+    gr.Markdown("# 🧠 Synapsera X: The Cognitive Operating System")
+    with gr.Row():
+        with gr.Column(scale=1, min_width=400):
+            gr.Markdown("### 🚀 Control Deck")
+            synthesis_mode = gr.Radio(["Analyze Thought", "Build Application"], label="Objective", value="Analyze Thought")
+            text_input = gr.Textbox(lines=10, label="Input Your Core Thought or Application Idea", placeholder="e.g., A decentralized social network for scientists to share and peer-review pre-print research papers, with a token-based reputation system.")
+            synthesize_btn = gr.Button("Engage Synapsera", variant="primary", size="lg")
+        with gr.Column(scale=2):
+            with gr.Accordion("🔴 Thought Terminal (Live Log)", open=True):
+                terminal_output = gr.Markdown("Status: **IDLE**. Awaiting engagement...")
+            with gr.Blocks(visible=True) as analysis_canvas:
+                gr.Markdown("### 🌌 Cognitive Nebula")
+                plot_3d = gr.Plot()
+                gr.Markdown("### 🏛️ Cognitive Council Analysis")
+                with gr.Row():
+                    critic_output = gr.Markdown("### The Critic\n*Awaiting analysis...*")
+                    visionary_output = gr.Markdown("### The Visionary\n*Awaiting analysis...*")
+                    pragmatist_output = gr.Markdown("### The Pragmatist\n*Awaiting analysis...*")
+            with gr.Blocks(visible=False) as build_canvas:
+                with gr.Tabs():
+                    with gr.Tab("v2 (Self-Corrected)"):
+                        live_preview_v2 = gr.HTML()
+                    with gr.Tab("v1 (Initial Draft)"):
+                        live_preview_v1 = gr.HTML()
+                download_button = gr.File(label="Download Full Project (.zip)", visible=False, interactive=False)
+    # --- Event Handlers ---
+    def on_mode_change(mode):
+        return gr.update(visible=(mode == "Analyze Thought")), gr.update(visible=(mode == "Build Application"))
+    synthesis_mode.change(on_mode_change, inputs=synthesis_mode, outputs=[analysis_canvas, build_canvas])
+    synthesize_btn.click(
+        universal_synthesis,
+        inputs=[synthesis_mode, text_input],
+        outputs=[terminal_output, plot_3d, critic_output, visionary_output, pragmatist_output, download_button]
+    ).then(
+        # A second .then() block to handle the build canvas outputs separately, which is a more robust pattern.
+        lambda: (None, None), # Dummy function to trigger updates
+        None,
+        [live_preview_v1, live_preview_v2],
+        show_progress=False
+    )
+if __name__ == "__main__":
+    demo.queue().launch(debug=True)