Update app.py

app.py

@@ -1,237 +1,216 @@
 import os
-import re
-from typing import Dict, List, Optional, Tuple
-import base64
-import mimetypes
-import PyPDF2
-import docx
-import cv2
-import numpy as np
-from PIL import Image
-import pytesseract
-import requests
-from urllib.parse import urlparse, urljoin
-from bs4 import BeautifulSoup
 import json
-import zipfile
-import io
-import asyncio
-
+from typing import Dict, List, Optional
 import gradio as gr
+from fastapi import FastAPI
 from huggingface_hub import InferenceClient
+import asyncio
+import plotly.graph_objects as go
+import networkx as nx
+import zipfile
+import io
 from tavily import TavilyClient
+import PyPDF2
+import docx
+from PIL import Image
+import pytesseract
 
-# --- AnyCoder Ω: The Cognitive-Generative IDE ---
-
-# --- Multi-Mode Prompt Engineering ---
+# --- Synapsera Ω Prime: The Definitive Cognitive-Generative OS ---
 
-# 1. For Standard Code Generation (AnyCoder Classic)
-CODE_GEN_PROMPT = """You are a helpful coding assistant. You help users create applications by generating code based on their requirements. 
-When asked to create an application, you should:
-1. Understand the user's requirements and any provided context (like web search results or file content).
-2. Generate clean, working, single-file HTML applications.
-3. Use Tailwind CSS via CDN for all styling.
-4. Embed all JavaScript logic within the HTML file.
-5. Provide a complete, functional application, not just a snippet.
-6. For website redesign tasks, use the provided original HTML as a starting point, preserving content and structure while modernizing the design.
-Always output ONLY the raw HTML code inside a ```html ... ``` code block.
-"""
+# --- Agent Prompts ---
+SYNTHESIS_AGENT_PROMPT = "You are the **Synthesis Agent**. Analyze the user's input and provided web context. Create a foundational Semantic Thought Graph. Output ONLY a valid JSON object with 'summary', 'nodes', and 'edges'."
+CRITIC_AGENT_PROMPT = "You are **THE CRITIC**. Analyze the provided Thought Graph. Ruthlessly identify every logical fallacy, weak assumption, and market risk. Be concise and direct. Output as Markdown."
+VISIONARY_AGENT_PROMPT = "You are **THE VISIONARY**. Analyze the provided Thought Graph. Identify emergent patterns and high-impact 'what if' scenarios. Extrapolate the idea into its most ambitious form. Output as an inspiring Markdown report."
+ARCHITECT_AGENT_PROMPT = "You are the **Architect Agent**. Given a user request, generate a complete, single-file HTML application using Tailwind CSS via CDN. Your output must be ONLY the raw HTML code."
+WEB_SEARCH_PROMPT = "Based on the user's idea, generate a JSON list of 3-5 concise, factual web search queries. Output ONLY the JSON. Example: {\"queries\": [\"market size for X\"]}"
 
-# 2. For Concept Analysis (The Synapsera Engine)
-CRITIC_AGENT_PROMPT = "You are **THE CRITIC**. Analyze the user's idea and the provided web search context. Identify every logical fallacy, weak assumption, market risk, and potential point of failure. Be ruthless, concise, and output your analysis as a Markdown bullet list."
-VISIONARY_AGENT_PROMPT = "You are **THE VISIONARY**. Analyze the user's idea and the provided web search context. Identify emergent patterns, latent potential, and high-impact 'what if' scenarios. Extrapolate the idea into its most ambitious form. Output your analysis as an inspiring Markdown report."
+# --- Multi-Model Configuration ---
+SYNTHESIS_MODEL = "mistralai/Mixtral-8x22B-Instruct-v0.1"
+CRITIC_MODEL = "mistralai/Mixtral-8x22B-Instruct-v0.1"
+VISIONARY_MODEL = "meta-llama/Meta-Llama-3-70B-Instruct"
+ARCHITECT_MODEL = "deepseek-ai/deepseek-coder-v2-lite-instruct"
 
-# --- Client & Model Configuration ---
+# --- Client Initialization ---
 HF_TOKEN = os.getenv('HF_TOKEN')
 TAVILY_API_KEY = os.getenv('TAVILY_API_KEY')
-
 client = InferenceClient(token=HF_TOKEN)
 tavily_client = TavilyClient(api_key=TAVILY_API_KEY) if TAVILY_API_KEY else None
 
-# Define models for different agent roles
-CODE_MODEL_ID = "deepseek-ai/deepseek-coder-v2-lite-instruct"
-CRITIC_MODEL_ID = "mistralai/Mixtral-8x22B-Instruct-v0.1"
-VISIONARY_MODEL_ID = "meta-llama/Meta-Llama-3-70B-Instruct"
-
-# --- Helper Functions (File Processing, ZIP Creation, etc.) ---
-
-def extract_text_from_file(file_path):
-    if not file_path: return ""
-    ext = os.path.splitext(file_path)[1].lower()
-    try:
-        if ext == ".pdf":
-            with open(file_path, "rb") as f:
-                reader = PyPDF2.PdfReader(f)
-                return "\n".join(page.extract_text() or "" for page in reader.pages)
-        elif ext in [".txt", ".md", ".csv"]:
-            with open(file_path, "r", encoding="utf-8") as f: return f.read()
-        elif ext == ".docx":
-            doc = docx.Document(file_path)
-            return "\n".join([para.text for para in doc.paragraphs])
-        return f"File type {ext} not supported for text extraction."
-    except Exception as e: return f"Error reading file: {e}"
-
-def remove_code_block(text):
-    match = re.search(r'```(?:html|HTML)\n([\s\S]+?)\n```', text, re.DOTALL)
-    return match.group(1).strip() if match else text.strip()
+# --- Helper Functions ---
+def render_3d_graph(graph_data: Optional[Dict] = None):
+    if not graph_data or not graph_data.get('nodes'):
+        return go.Figure(layout={"title_text": "Cognitive Nebula Awaiting Synthesis...", "template": "plotly_dark", "height": 600})
+    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=70)
+    node_ids_in_order = list(G.nodes())
+    pos_data = [pos[node_id] for node_id in node_ids_in_order]
+    node_x, node_y, node_z = zip(*pos_data) if pos_data else ([], [], [])
+    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])
+    node_info = {n['id']: n for n in graph_data['nodes']}
+    node_trace = go.Scatter3d(x=node_x, y=node_y, z=node_z, mode='markers+text',
+        text=[f"<b>{node_info[node_id]['label']}</b>" for node_id in node_ids_in_order],
+        customdata=[json.dumps(node_info[node_id]) for node_id in node_ids_in_order],
+        hoverinfo='text', hovertext=[f"<b>{node_info[node_id]['label']}</b><br>Type: {node_info[node_id]['type']}" for node_id in node_ids_in_order],
+        marker=dict(size=12, line=dict(width=2)))
+    edge_trace = go.Scatter3d(x=edge_x, y=edge_y, z=edge_z, mode='lines', line=dict(color='#888', width=1), hoverinfo='none')
+    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=600, clickmode='event+select')
+    return fig
 
 def create_zip_file(html_content: str, user_prompt: str) -> Optional[str]:
     if not html_content: return None
     zip_buffer = io.BytesIO()
     with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
-        readme = f"# AnyCoder Ω Generated Application\n\nThis project was generated based on the following prompt:\n\n> {user_prompt}"
+        readme = f"# Synapsera-Built Application\n\n> {user_prompt}"
         zf.writestr("index.html", html_content)
         zf.writestr("README.md", readme)
-    zip_path = "/tmp/application.zip"
+    zip_path = "/tmp/synapsera_project.zip"
     with open(zip_path, "wb") as f: f.write(zip_buffer.getvalue())
     return zip_path
 
-# --- Core Logic for Analysis and Generation ---
-
-async def run_agent(prompt: str, context: str, model_id: str):
-    """Generic function to run an agent asynchronously."""
+# --- Core Asynchronous Multi-Agent Logic ---
+async def run_agent(prompt: str, context: str, model_id: str, json_mode: bool = False):
     messages = [{"role": "system", "content": prompt}, {"role": "user", "content": context}]
+    response_format = {"type": "json_object"} if json_mode else None
     try:
-        loop = asyncio.get_running_loop()
-        response = await loop.run_in_executor(
-            None,
-            lambda: client.chat_completion(model=model_id, messages=messages, max_tokens=2048)
-        )
-        return response.choices[0].message.content or "Agent returned an empty response."
+        response = await asyncio.to_thread(
+            client.chat_completion, model=model_id, messages=messages, max_tokens=8192, response_format=response_format)
+        return response.choices[0].message.content or ""
     except Exception as e:
-        return f"Agent Error ({model_id}): {e}"
+        return json.dumps({"error": f"Agent {model_id} failed: {e}"})
 
-async def perform_concept_analysis(text_input, file_path, progress=gr.Progress(track_tqdm=True)):
-    """Orchestrates the Cognitive Council and Web Search for analysis."""
-    progress(0, desc="Initiating Analysis...")
-    
-    # Step 1: Prepare Context
-    context = text_input
-    if file_path: context += f"\n\n--- Document Content ---\n{extract_text_from_file(file_path)}"
-    
-    # Step 2: Web Search
-    progress(0.2, desc="Engaging Tavily Web Search...")
-    web_context = "Web search disabled or API key not set."
-    if tavily_client:
-        try:
-            search_results = tavily_client.search(query=f"Market analysis and technical considerations for: {text_input}", search_depth="advanced", max_results=5)
-            web_context = "\n\n---\n\n".join([f"**Source:** {res['title']}\n{res['content']}" for res in search_results['results']])
-        except Exception as e:
-            web_context = f"Web search failed: {e}"
-
-    full_context_for_agents = f"{context}\n\n--- Web Search Context ---\n{web_context}"
-    
-    # Step 3: Run Cognitive Council in Parallel
-    progress(0.5, desc="Convening Cognitive Council...")
-    critic_task = asyncio.create_task(run_agent(CRITIC_AGENT_PROMPT, full_context_for_agents, CRITIC_MODEL_ID))
-    visionary_task = asyncio.create_task(run_agent(VISIONARY_AGENT_PROMPT, full_context_for_agents, VISIONARY_MODEL_ID))
-    
-    critic_report = await critic_task
-    visionary_report = await visionary_task
-    progress(1, desc="Analysis Complete.")
-
-    analysis_summary = f"""
-## 🧠 Cognitive Council Analysis
-
-### visionary-thoughts ✨ The Visionary's Report
-{visionary_report}
-
-### critical-analysis 🧐 The Critic's Report
-{critic_report}
-
----
-
-## 🌐 Web Search Context
-{web_context}
-"""
-    return analysis_summary, full_context_for_agents, gr.update(visible=True)
-
-def generate_application_code(context: str, progress=gr.Progress(track_tqdm=True)):
-    """Generates the application code."""
-    progress(0, desc="Engaging Code Generation Engine...")
-    
-    # For a single-file generator, we don't need async here, but we could add it.
-    response = client.chat_completion(
-        model=CODE_MODEL_ID,
-        messages=[{"role": "system", "content": CODE_GEN_PROMPT}, {"role": "user", "content": context}],
-        max_tokens=8192,
-        stream=False # We need the full code to process it
-    )
-    raw_code = response.choices[0].message.content or ""
-    clean_code = remove_code_block(raw_code)
-    
-    progress(1, desc="Build Complete.")
-    
-    zip_path = create_zip_file(clean_code, context.split("\n\n---")[0])
+async def get_web_context(text_input: str, model_id: str):
+    if not tavily_client: return "*Tavily client not configured. Skipping web search.*"
+    try:
+        search_queries_str = await run_agent(WEB_SEARCH_PROMPT, text_input, model_id, json_mode=True)
+        search_queries = json.loads(search_queries_str).get("queries", [])
+        if not search_queries: return "No relevant search queries were generated."
+        search_results = await asyncio.to_thread(tavily_client.search, query=" ".join(search_queries), search_depth="advanced", max_results=3)
+        return "\n\n---\n\n".join([f"**Source:** {res['title']}\n{res['content']}" for res in search_results['results']])
+    except Exception as e: return f"Web search failed: {e}"
+
+async def universal_synthesis_flow(synthesis_mode, text_input, progress=gr.Progress(track_tqdm=True)):
+    yield {terminal_output: gr.update(value="`[STATUS] Engaging Synapsera OS...`")}
     
-    return clean_code, clean_code, zip_path
+    web_context = await get_web_context(text_input, SYNTHESIS_MODEL)
+    yield {terminal_output: gr.update(value=f"`[STATUS] Web context acquired.`\n\n**Web Search Summary:**\n{web_context[:400]}...")}
+    full_context = f"User Idea: {text_input}\n\nWeb Context:\n{web_context}"
+
+    if synthesis_mode == "Analyze Thought":
+        graph_json_str = await run_agent(SYNTHESIS_AGENT_PROMPT, full_context, SYNTHESIS_MODEL, json_mode=True)
+        try: graph_data = json.loads(graph_json_str)
+        except json.JSONDecodeError:
+            yield {terminal_output: gr.update(value=f"`[FATAL] Synthesis Agent failed.`")}
+            return
+        yield {
+            session_state: graph_data,
+            terminal_output: gr.update(value="`[STATUS] Thought Model synthesized. Convening Cognitive Council...`"),
+            cognitive_nebula: render_3d_graph(graph_data)
+        }
+        council_context = f"Thought Graph:\n{graph_json_str}\n\nWeb Context:\n{web_context}"
+        critic_task = run_agent(CRITIC_AGENT_PROMPT, council_context, CRITIC_MODEL)
+        visionary_task = run_agent(VISIONARY_AGENT_PROMPT, council_context, VISIONARY_MODEL)
+        critic_res, visionary_res = await asyncio.gather(critic_task, visionary_task)
+        yield {
+            terminal_output: gr.update(value="`[COMPLETE] Cognitive Council session concluded.`"),
+            critic_output: critic_res, visionary_output: visionary_res,
+            build_from_analysis_btn: gr.update(visible=True)
+        }
+    else: # Build Application
+        generated_code = await run_agent(ARCHITECT_AGENT_PROMPT, full_context, ARCHITECT_MODEL)
+        zip_path = create_zip_file(generated_code, text_input)
+        yield {
+            terminal_output: gr.update(value="`[COMPLETE] Application build complete.`"),
+            live_preview: generated_code, source_code: generated_code,
+            download_button: gr.update(value=zip_path, visible=True)
+        }
 
 # --- Gradio UI Definition ---
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple"), title="AnyCoder Ω") as demo:
-    
-    # State to hold the full context after analysis
-    analysis_context = gr.State("")
-
-    gr.Markdown("# 🤖 AnyCoder Ω: The Cognitive-Generative IDE")
-    gr.Markdown("From raw idea, to deep analysis, to fully-built application in one seamless workflow.")
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple"), css="footer{display:none !important}") as gradio_app:
+    session_state = gr.State({})
 
+    gr.Markdown("# 🧠 Synapsera Ω Prime: The Cognitive-Generative OS")
+    
     with gr.Row():
-        with gr.Column(scale=2, min_width=500):
+        with gr.Column(scale=1, min_width=450):
             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="A decentralized platform for peer-reviewing scientific research...")
+            synthesize_btn = gr.Button("Engage Synapsera", variant="primary", size="lg")
+            build_from_analysis_btn = gr.Button("Build This Analyzed Concept ⚡️", variant="secondary", visible=False)
+
+        with gr.Column(scale=2):
+            terminal_output = gr.Markdown("`[STATUS] Idle`")
             
-            with gr.Accordion("1. Define Your Objective & Input", open=True):
-                objective_selector = gr.Radio(
-                    ["Analyze Concept", "Generate Application / Redesign"],
-                    label="What is your goal?",
-                    value="Generate Application / Redesign"
-                )
-                prompt_input = gr.Textbox(lines=5, label="Describe your concept or application", placeholder="e.g., A minimalist pomodoro timer with customizable work/break intervals and a calming background.")
-                file_input = gr.File(label="Upload Supporting Document (Optional)", type="filepath")
-                
-            generate_button = gr.Button("Engage Engine", variant="primary", size="lg")
-            build_from_analysis_button = gr.Button("Build This Concept ⚡️", variant="primary", size="lg", visible=False)
-
-        with gr.Column(scale=3):
-            with gr.Tabs() as output_tabs:
-                with gr.Tab("Analysis", id="analysis_tab"):
-                    analysis_output = gr.Markdown("Analysis will appear here after running 'Analyze Concept'.")
-                
-                with gr.Tab("Preview", id="preview_tab"):
-                    preview_output = gr.HTML(label="Live Preview")
-                    download_button = gr.File(label="Download Project as .zip", visible=False, interactive=False)
-
-                with gr.Tab("Code", id="code_tab"):
-                    code_output = gr.Code(language="html", label="Generated Code")
-                    
-    # --- Event Handlers ---
+            with gr.Blocks(visible=True) as analysis_canvas:
+                cognitive_nebula = gr.Plot()
+                with gr.Tabs():
+                    with gr.Tab("🔬 Focus Panel"):
+                        focus_panel_md = gr.Markdown("Click a node on the graph to focus.")
+                    with gr.Tab("🧐 The Critic's Report"):
+                        critic_output = gr.Markdown("*Awaiting analysis...*")
+                    with gr.Tab("✨ The Visionary's Report"):
+                        visionary_output = gr.Markdown("*Awaiting analysis...*")
+
+            with gr.Blocks(visible=False) as build_canvas:
+                with gr.Tabs():
+                    with gr.Tab("🚀 Live Preview"):
+                        live_preview = gr.HTML()
+                    with gr.Tab("📄 Source Code"):
+                        source_code = gr.Code(language="html")
+                download_button = gr.File(label="Download Project (.zip)", visible=False, interactive=False)
 
-    # Main button click handler
-    async def on_generate_click(objective, prompt, file_obj):
-        if objective == "Analyze Concept":
-            analysis_html, full_context, build_btn_update = await perform_concept_analysis(prompt, file_obj.name if file_obj else None)
-            return analysis_html, full_context, build_btn_update, gr.update(selected="analysis_tab"), None, None, gr.update(visible=False)
-        else: # Generate Application
-            # In direct generation, the context is just the prompt
-            code, preview, zip_path = generate_application_code(prompt)
-            return "Direct code generation complete.", "", gr.update(visible=False), gr.update(selected="preview_tab"), code, preview, gr.update(value=zip_path, visible=True)
-
-    generate_button.click(
-        on_generate_click,
-        inputs=[objective_selector, prompt_input, file_input],
-        outputs=[analysis_output, analysis_context, build_from_analysis_button, output_tabs, code_output, preview_output, download_button]
+    # --- Event Handlers ---
+    def on_mode_change(mode):
+        is_analysis = mode == "Analyze Thought"
+        return gr.update(visible=is_analysis), gr.update(visible=not is_analysis)
+    synthesis_mode.change(on_mode_change, inputs=synthesis_mode, outputs=[analysis_canvas, build_canvas])
+
+    synthesize_btn.click(
+        universal_synthesis_flow,
+        inputs=[synthesis_mode, text_input],
+        outputs=[session_state, terminal_output, cognitive_nebula, critic_output, visionary_output, build_from_analysis_btn, live_preview, source_code, download_button]
     )
 
-    # Handler for the "Build This Concept" button
-    def on_build_from_analysis_click(full_context_from_state):
-        code, preview, zip_path = generate_application_code(full_context_from_state)
-        return gr.update(selected="preview_tab"), code, preview, gr.update(value=zip_path, visible=True)
-
-    build_from_analysis_button.click(
-        on_build_from_analysis_click,
-        inputs=[analysis_context],
-        outputs=[output_tabs, code_output, preview_output, download_button]
+    def on_build_from_analysis(graph_data, progress=gr.Progress(track_tqdm=True)):
+        # This function is now simpler as it just calls the agent
+        full_context = f"User Idea:\n{graph_data.get('summary', '')}\n\nFull Thought Model:\n{json.dumps(graph_data, indent=2)}"
+        # We can't use async here directly, so we call the sync version or adapt
+        # For simplicity, we'll do a blocking call here.
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        generated_code = loop.run_until_complete(run_agent(ARCHITECT_AGENT_PROMPT, full_context, ARCHITECT_MODEL))
+        zip_path = create_zip_file(generated_code, graph_data.get('summary', ''))
+        return gr.update(visible=False), gr.update(visible=True), generated_code, generated_code, gr.update(value=zip_path, visible=True)
+
+    build_from_analysis_btn.click(
+        on_build_from_analysis,
+        inputs=[session_state],
+        outputs=[analysis_canvas, build_canvas, live_preview, source_code, download_button]
     )
 
-# --- Launch The IDE ---
-if __name__ == "__main__":
-    demo.queue().launch()
+    def select_node_from_graph(evt: gr.SelectData):
+        if evt.value:
+            # The customdata is a JSON string of the node object
+            node_data = json.loads(evt.customdata)
+            md_output = f"""
+            ### Node: {node_data.get('label')}
+            **Type:** {node_data.get('type')}
+            **Importance:** {node_data.get('importance')}
+            **Content:** {node_data.get('content')}
+            **Mirror Analysis:** {node_data.get('mirror_analysis')}
+            """
+            return md_output
+        return "Click a node on the graph to focus."
+    
+    cognitive_nebula.select(select_node_from_graph, outputs=[focus_panel_md])
+
+# --- FastAPI Application ---
+app = FastAPI()
+app = gr.mount_gradio_app(app, gradio_app, path="/")