Update app.py

app.py

@@ -15,12 +15,12 @@ from urllib.parse import quote
 import streamlit as st
 import streamlit.components.v1 as components
 
-# 🏰 If you do model inference via huggingface_hub
-# from huggingface_hub import InferenceClient
+# huggingface_hub usage if you do model inference
+#from huggingface_hub import InferenceClient
 
-# =====================================================================================
-#  1) GLOBAL CONFIG & PLACEHOLDERS
-# =====================================================================================
+########################################################################################
+# 1) GLOBAL CONFIG & PLACEHOLDERS
+########################################################################################
 BASE_URL = "https://huggingface.co/spaces/awacke1/MermaidMarkdownDiagramEditor"
 
 PromptPrefix = "AI-Search: "
@@ -42,45 +42,42 @@ transhuman_glossary = {
     "Cybernetics": ["Robotic Limbs", "Augmented Eyes"],
 }
 
+########################################################################################
+# 2) SIMPLE HELPER FUNCS
+########################################################################################
 
 def process_text(text):
     """🕵️ process_text: detective style—prints lines to Streamlit for debugging."""
     st.write(f"process_text called with: {text}")
 
-
 def search_arxiv(text):
     """🔭 search_arxiv: pretend to search ArXiv, just prints debug for now."""
     st.write(f"search_arxiv called with: {text}")
 
-
 def SpeechSynthesis(text):
-    """🗣 SpeechSynthesis: read lines out loud? Here, we log them for demonstration."""
+    """🗣 SpeechSynthesis: read lines out loud? For demo, we just log them."""
     st.write(f"SpeechSynthesis called with: {text}")
 
-
 def process_image(image_file, prompt):
     """📷 process_image: imagine an AI pipeline for images, here we just log."""
     return f"[process_image placeholder] {image_file} => {prompt}"
 
-
 def process_video(video_file, seconds_per_frame):
     """🎞 process_video: placeholder for video tasks, logs to Streamlit."""
     st.write(f"[process_video placeholder] {video_file}, {seconds_per_frame} sec/frame")
 
-
 API_URL = "https://huggingface-inference-endpoint-placeholder"
 API_KEY = "hf_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
 
-
 @st.cache_resource
 def InferenceLLM(prompt):
     """🔮 InferenceLLM: a stub returning a mock response for 'prompt'."""
     return f"[InferenceLLM placeholder response to prompt: {prompt}]"
 
+########################################################################################
+# 3) GLOSSARY & FILE UTILITY
+########################################################################################
 
-# =====================================================================================
-#  2) GLOSSARY & FILE UTILITY
-# =====================================================================================
 @st.cache_resource
 def display_glossary_entity(k):
     """
@@ -88,20 +85,19 @@ def display_glossary_entity(k):
     Each link might point to /?q=..., /?q=<prefix>..., or external sites.
     """
     search_urls = {
-        "🚀🌌ArXiv": lambda x: f"/?q={quote(x)}",
-        "🃏Analyst": lambda x: f"/?q={quote(x)}-{quote(PromptPrefix)}",
-        "📚PyCoder": lambda x: f"/?q={quote(x)}-{quote(PromptPrefix2)}",
-        "🔬JSCoder": lambda x: f"/?q={quote(x)}-{quote(PromptPrefix3)}",
-        "📖": lambda x: f"https://en.wikipedia.org/wiki/{quote(x)}",
-        "🔍": lambda x: f"https://www.google.com/search?q={quote(x)}",
-        "🔎": lambda x: f"https://www.bing.com/search?q={quote(x)}",
-        "🎥": lambda x: f"https://www.youtube.com/results?search_query={quote(x)}",
-        "🐦": lambda x: f"https://twitter.com/search?q={quote(x)}",
+        "🚀🌌ArXiv":   lambda x: f"/?q={quote(x)}",
+        "🃏Analyst":  lambda x: f"/?q={quote(x)}-{quote(PromptPrefix)}",
+        "📚PyCoder":  lambda x: f"/?q={quote(x)}-{quote(PromptPrefix2)}",
+        "🔬JSCoder":  lambda x: f"/?q={quote(x)}-{quote(PromptPrefix3)}",
+        "📖":         lambda x: f"https://en.wikipedia.org/wiki/{quote(x)}",
+        "🔍":         lambda x: f"https://www.google.com/search?q={quote(x)}",
+        "🔎":         lambda x: f"https://www.bing.com/search?q={quote(x)}",
+        "🎥":         lambda x: f"https://www.youtube.com/results?search_query={quote(x)}",
+        "🐦":         lambda x: f"https://twitter.com/search?q={quote(x)}",
     }
     links_md = ' '.join([f"[{emoji}]({url(k)})" for emoji, url in search_urls.items()])
     st.markdown(f"**{k}** <small>{links_md}</small>", unsafe_allow_html=True)
 
-
 def display_content_or_image(query):
     """
     If 'query' is in transhuman_glossary or there's an image matching 'images/<query>.png',
@@ -120,15 +116,14 @@ def display_content_or_image(query):
     st.warning("No matching content or image found.")
     return False
 
-
 def clear_query_params():
-    """For fully clearing, you'd do a redirect or st.experimental_set_query_params()."""
+    """If you want to truly remove them, do a redirect or st.experimental_set_query_params()."""
     st.warning("Define a redirect or link without query params if you want to truly clear them.")
 
+########################################################################################
+# 4) FILE-HANDLING (MD files, etc.)
+########################################################################################
 
-# =====================================================================================
-#  3) FILE-HANDLING (MD files, etc.)
-# =====================================================================================
 def load_file(file_path):
     """Load file contents as UTF-8 text, or return empty on error."""
     try:
@@ -137,7 +132,6 @@ def load_file(file_path):
     except:
         return ""
 
-
 @st.cache_resource
 def create_zip_of_files(files):
     """Combine multiple local files into a single .zip for user to download."""
@@ -147,7 +141,6 @@ def create_zip_of_files(files):
             zipf.write(file)
     return zip_name
 
-
 @st.cache_resource
 def get_zip_download_link(zip_file):
     """Return an <a> link to download the given zip_file (base64-encoded)."""
@@ -156,7 +149,6 @@ def get_zip_download_link(zip_file):
     b64 = base64.b64encode(data).decode()
     return f'<a href="data:application/zip;base64,{b64}" download="{zip_file}">Download All</a>'
 
-
 def get_table_download_link(file_path):
     """
     Creates a download link for a single file from your snippet.
@@ -169,36 +161,31 @@ def get_table_download_link(file_path):
         file_name = os.path.basename(file_path)
         ext = os.path.splitext(file_name)[1]
         mime_map = {
-            '.txt': 'text/plain',
-            '.py': 'text/plain',
+            '.txt':  'text/plain',
+            '.py':   'text/plain',
             '.xlsx': 'text/plain',
-            '.csv': 'text/plain',
-            '.htm': 'text/html',
-            '.md': 'text/markdown',
-            '.wav': 'audio/wav'
+            '.csv':  'text/plain',
+            '.htm':  'text/html',
+            '.md':   'text/markdown',
+            '.wav':  'audio/wav'
         }
         mime_type = mime_map.get(ext, 'application/octet-stream')
         return f'<a href="data:{mime_type};base64,{b64}" target="_blank" download="{file_name}">{file_name}</a>'
     except:
         return ''
 
-
 def get_file_size(file_path):
     """Get file size in bytes."""
     return os.path.getsize(file_path)
 
-
 def FileSidebar():
     """
     Renders .md files in the sidebar with open/view/run/delete logic.
     """
     all_files = glob.glob("*.md")
-    # If you want to filter out short-named or special files:
     all_files = [f for f in all_files if len(os.path.splitext(f)[0]) >= 5]
-    # sorting in place
     all_files.sort(key=lambda x: (os.path.splitext(x)[1], x), reverse=True)
 
-    # Buttons for "Delete All" and "Download"
     Files1, Files2 = st.sidebar.columns(2)
     with Files1:
         if st.button("🗑 Delete All"):
@@ -214,11 +201,10 @@ def FileSidebar():
     file_name = ''
     next_action = ''
 
-    # Each file row
     for file in all_files:
-        col1, col2, col3, col4, col5 = st.sidebar.columns([1, 6, 1, 1, 1])
+        col1, col2, col3, col4, col5 = st.sidebar.columns([1,6,1,1,1])
         with col1:
-            if st.button("🌐", key="md_" + file):
+            if st.button("🌐", key="md_"+file):
                 file_contents = load_file(file)
                 file_name = file
                 next_action = 'md'
@@ -226,7 +212,7 @@ def FileSidebar():
         with col2:
             st.markdown(get_table_download_link(file), unsafe_allow_html=True)
         with col3:
-            if st.button("📂", key="open_" + file):
+            if st.button("📂", key="open_"+file):
                 file_contents = load_file(file)
                 file_name = file
                 next_action = 'open'
@@ -235,13 +221,13 @@ def FileSidebar():
                 st.session_state['filetext'] = file_contents
                 st.session_state['next_action'] = next_action
         with col4:
-            if st.button("▶️", key="read_" + file):
+            if st.button("▶️", key="read_"+file):
                 file_contents = load_file(file)
                 file_name = file
                 next_action = 'search'
                 st.session_state['next_action'] = next_action
         with col5:
-            if st.button("🗑", key="delete_" + file):
+            if st.button("🗑", key="delete_"+file):
                 os.remove(file)
                 st.rerun()
 
@@ -251,7 +237,6 @@ def FileSidebar():
             with open1:
                 file_name_input = st.text_input('File Name:', file_name, key='file_name_input')
                 file_content_area = st.text_area('File Contents:', file_contents, height=300, key='file_content_area')
-
                 if st.button('💾 Save File'):
                     with open(file_name_input, 'w', encoding='utf-8') as f:
                         f.write(file_content_area)
@@ -270,18 +255,15 @@ def FileSidebar():
             if st.button("🔍Run"):
                 st.write("Running GPT logic placeholder...")
 
-
-# =====================================================================================
-#  4) SCORING / GLOSSARIES
-# =====================================================================================
+########################################################################################
+# 5) SCORING / GLOSSARIES
+########################################################################################
 score_dir = "scores"
 os.makedirs(score_dir, exist_ok=True)
 
-
 def generate_key(label, header, idx):
     return f"{header}_{label}_{idx}_key"
 
-
 def update_score(key, increment=1):
     """Increment the 'score' for a glossary item in JSON storage."""
     score_file = os.path.join(score_dir, f"{key}.json")
@@ -296,7 +278,6 @@ def update_score(key, increment=1):
         json.dump(score_data, file)
     return score_data["score"]
 
-
 def load_score(key):
     """Load the stored score from .json if it exists, else 0."""
     file_path = os.path.join(score_dir, f"{key}.json")
@@ -306,31 +287,30 @@ def load_score(key):
         return score_data["score"]
     return 0
 
-
 def display_buttons_with_scores(num_columns_text):
     """
     Show glossary items as clickable buttons, each increments a 'score'.
     """
     game_emojis = {
         "Dungeons and Dragons": "🐉",
-        "Call of Cthulhu": "🐙",
-        "GURPS": "🎲",
-        "Pathfinder": "🗺️",
-        "Kindred of the East": "🌅",
-        "Changeling": "🍃",
+        "Call of Cthulhu":       "🐙",
+        "GURPS":                 "🎲",
+        "Pathfinder":            "🗺️",
+        "Kindred of the East":   "🌅",
+        "Changeling":            "🍃",
     }
     topic_emojis = {
-        "Core Rulebooks": "📚",
-        "Maps & Settings": "🗺️",
-        "Game Mechanics & Tools": "⚙️",
-        "Monsters & Adversaries": "👹",
-        "Campaigns & Adventures": "📜",
-        "Creatives & Assets": "🎨",
-        "Game Master Resources": "🛠️",
-        "Lore & Background": "📖",
-        "Character Development": "🧍",
-        "Homebrew Content": "🔧",
-        "General Topics": "🌍",
+        "Core Rulebooks":            "📚",
+        "Maps & Settings":           "🗺️",
+        "Game Mechanics & Tools":    "⚙️",
+        "Monsters & Adversaries":    "👹",
+        "Campaigns & Adventures":    "📜",
+        "Creatives & Assets":        "🎨",
+        "Game Master Resources":     "🛠️",
+        "Lore & Background":         "📖",
+        "Character Development":     "🧍",
+        "Homebrew Content":          "🔧",
+        "General Topics":            "🌍",
     }
 
     for category, games in roleplaying_glossary.items():
@@ -345,10 +325,10 @@ def display_buttons_with_scores(num_columns_text):
                     newscore = update_score(key.replace('?', ''))
                     st.markdown(f"Scored **{category} - {game} - {term}** -> {newscore}")
 
+########################################################################################
+# 6) IMAGES & VIDEOS
+########################################################################################
 
-# =====================================================================================
-#  5) IMAGES & VIDEOS
-# =====================================================================================
 def display_images_and_wikipedia_summaries(num_columns=4):
     """Display .png images in a grid, referencing the name as a 'keyword'."""
     image_files = [f for f in os.listdir('.') if f.endswith('.png')]
@@ -359,7 +339,6 @@ def display_images_and_wikipedia_summaries(num_columns=4):
     image_files_sorted = sorted(image_files, key=lambda x: len(x.split('.')[0]))
     cols = st.columns(num_columns)
     col_index = 0
-
     for image_file in image_files_sorted:
         with cols[col_index % num_columns]:
             try:
@@ -375,7 +354,6 @@ def display_images_and_wikipedia_summaries(num_columns=4):
                 st.write(f"Could not open {image_file}")
         col_index += 1
 
-
 def display_videos_and_links(num_columns=4):
     """Displays all .mp4/.webm in a grid, plus text input for prompts."""
     video_files = [f for f in os.listdir('.') if f.endswith(('.mp4', '.webm'))]
@@ -386,7 +364,6 @@ def display_videos_and_links(num_columns=4):
     video_files_sorted = sorted(video_files, key=lambda x: len(x.split('.')[0]))
     cols = st.columns(num_columns)
     col_index = 0
-
     for video_file in video_files_sorted:
         with cols[col_index % num_columns]:
             k = video_file.split('.')[0]
@@ -401,10 +378,10 @@ def display_videos_and_links(num_columns=4):
                     st.error("Invalid input for seconds per frame!")
         col_index += 1
 
+########################################################################################
+# 7) MERMAID
+########################################################################################
 
-# =====================================================================================
-#  6) MERMAID & PARTIAL SUBGRAPH LOGIC
-# =====================================================================================
 def generate_mermaid_html(mermaid_code: str) -> str:
     """Embed mermaid_code in a minimal HTML snippet, centered."""
     return f"""
@@ -433,160 +410,82 @@ def generate_mermaid_html(mermaid_code: str) -> str:
     </html>
     """
 
-
 def append_model_param(url: str, model_selected: bool) -> str:
-    """If user selects 'model=1', we append &model=1 or ?model=1 if not present."""
+    """If user checks 'model=1', we append &model=1 or ?model=1 if not present."""
     if not model_selected:
         return url
     delimiter = "&" if "?" in url else "?"
     return f"{url}{delimiter}model=1"
 
-
 def inject_base_url(url: str) -> str:
     """If link doesn't start with 'http', prepend BASE_URL so it's absolute."""
     if url.startswith("http"):
         return url
     return f"{BASE_URL}{url}"
 
+########################################################################################
+# 8) NEW MERMAID CODE - NO DOUBLE QUOTES, USE UPPER/LOWER MERGING
+########################################################################################
+
+# The user wants no double quotes, plus a middle word like OpenUser
+# Example usage:
+#   click U /?q=U OpenUser _blank
+#   which might cause syntax issues in older Mermaid, but we'll do it anyway.
 
-# We'll keep the default mermaid that references /?q=...
 DEFAULT_MERMAID = r"""
 flowchart LR
-    U((User 😎)) -- "Talk 🗣️" --> LLM[LLM Agent 🤖\nExtract Info]
-    click U "/?q=U" "Open 'User 😎'" _blank
-    click LLM "/?q=LLM%20Agent%20Extract%20Info" "Open LLM Agent" _blank
+    U((User😎)) -- Talk🗣 --> LLM[LLMAgent🤖\nExtractInfo]
+    click U /?q=U OpenUser _blank
+    click LLM /?q=LLM%20Agent%20ExtractInfo OpenLLM _blank
 
-    LLM -- "Query 🔍" --> HS[Hybrid Search 🔎\nVector+NER+Lexical]
-    click HS "/?q=Hybrid%20Search%20Vector+NER+Lexical" "Open Hybrid Search" _blank
+    LLM -- Query🔍 --> HS[HybridSearch🔎\nVectorNERLexical]
+    click HS /?q=HybridSearchVectorNERLexical LaunchSearch _blank
 
-    HS -- "Reason 🤔" --> RE[Reasoning Engine 🛠️\nNeuralNetwork+Medical]
-    click RE "/?q=Reasoning%20Engine%20NeuralNetwork+Medical" "Open Reasoning" _blank
+    HS -- Reason🤔 --> RE[ReasoningEngine🛠️\nNeuralNetworkMedical]
+    click RE /?q=ReasoningEngineNeuralNetworkMedical BrainTool _blank
 
-    RE -- "Link 📡" --> KG((Knowledge Graph 📚\nOntology+GAR+RAG))
-    click KG "/?q=Knowledge%20Graph%20Ontology+GAR+RAG" "Open Knowledge Graph" _blank
+    RE -- Link📡 --> KG((KnowledgeGraph📚\nOntologyGAR RAG))
+    click KG /?q=KnowledgeGraphOntologyGARRAG ShowKG _blank
 """
 
+########################################################################################
+# 9) MAIN UI
+########################################################################################
 
-def parse_mermaid_edges(mermaid_text: str):
-    """
-    🍿 parse_mermaid_edges:
-      - Find lines like: A -- "Label" --> B
-      - Return adjacency dict: edges[A] = [(label, B), ...]
-    """
-    adjacency = {}
-    # e.g. U((User 😎)) -- "Talk 🗣️" --> LLM[LLM Agent 🤖\nExtract Info]
-    edge_pattern = re.compile(r'(\S+)\s*--\s*"([^"]*)"\s*-->\s*(\S+)')
-    for line in mermaid_text.split('\n'):
-        match = edge_pattern.search(line.strip())
-        if match:
-            nodeA, label, nodeB = match.groups()
-            if nodeA not in adjacency:
-                adjacency[nodeA] = []
-            adjacency[nodeA].append((label, nodeB))
-    return adjacency
-
-
-def bfs_subgraph(adjacency, start_node, depth=1):
-    """
-    🍎 bfs_subgraph:
-      - Gather edges up to 'depth' levels from start_node
-      - If depth=1, only direct edges from node
-    """
-    from collections import deque
-    visited = set()
-    queue = deque([(start_node, 0)])
-    edges = []
-
-    while queue:
-        current, lvl = queue.popleft()
-        if current in visited:
-            continue
-        visited.add(current)
-
-        if current in adjacency and lvl < depth:
-            for (label, child) in adjacency[current]:
-                edges.append((current, label, child))
-                queue.append((child, lvl + 1))
-
-    return edges
-
-
-def create_subgraph_mermaid(sub_edges, start_node):
-    """
-    🍄 create_subgraph_mermaid:
-      - build a smaller flowchart snippet with edges from BFS
-    """
-    sub_mermaid = "flowchart LR\n"
-    sub_mermaid += f"    %% SearchResult Subgraph for {start_node}\n"
-    if not sub_edges:
-        # If no edges, show just the node
-        sub_mermaid += f"    {start_node}\n"
-        sub_mermaid += "    %% End of partial subgraph\n"
-        return sub_mermaid
-    for (A, label, B) in sub_edges:
-        sub_mermaid += f'    {A} -- "{label}" --> {B}\n'
-    sub_mermaid += "    %% End of partial subgraph\n"
-    return sub_mermaid
-
-
-# =====================================================================================
-#  7) MAIN APP
-# =====================================================================================
 def main():
-    st.set_page_config(page_title="Mermaid + BFS Subgraph + Full Logic", layout="wide")
+    st.set_page_config(page_title="Mermaid with No Double Quotes", layout="wide")
 
     # 1) Query param parsing
     query_params = st.query_params
-    query_list = (query_params.get('q') or query_params.get('query') or [''])
-    q_or_query = query_list[0].strip() if len(query_list) > 0 else ""
-
-    # If 'action' param is present
-    if 'action' in query_params:
-        action_list = query_params['action']
-        if action_list:
-            action = action_list[0]
-            if action == 'show_message':
-                st.success("Showing a message because 'action=show_message' was found in the URL.")
-            elif action == 'clear':
-                clear_query_params()
-
-    # If there's a 'query=' param, display content or image
-    if 'query' in query_params:
-        query_val = query_params['query'][0]
-        display_content_or_image(query_val)
+    query = query_params.get('q', [""])[0].strip()
+    if query:
+        st.write("process_text called with:", PromptPrefix + query)
 
     # 2) Let user pick ?model=1
     st.sidebar.write("## Diagram Link Settings")
     model_selected = st.sidebar.checkbox("Append ?model=1 to each link?")
 
-    # 3) We'll parse adjacency from DEFAULT_MERMAID, then do the injection for base URL
-    #    and possible model param. We'll store the final mermaid code in session.
+    # 3) We'll do a minimal injection: if line starts with click and has /?q=, we add base & model
     lines = DEFAULT_MERMAID.strip().split("\n")
     new_lines = []
     for line in lines:
-        if "click " in line and '"/?' in line:
-            # try to parse out the URL
-            parts = re.split(r'click\s+\S+\s+"([^"]+)"\s+"([^"]+)"\s+(\S+)', line)
-            # For example: 
-            #  'click U "/?q=U" "Open 'User 😎'" _blank'
-            # might become: 
-            #  parts = [prefix, '/?q=U', "Open 'User 😎'", '_blank', '']
-            if len(parts) >= 4:
-                # Reassemble with base URL + optional model param
-                old_url = parts[1]
-                tooltip = parts[2]
-                target = parts[3]
-
-                # 1) base
+        # e.g.:  click U /?q=U OpenUser _blank
+        if line.strip().startswith("click ") and "/?q=" in line:
+            parts = line.split()
+            # Example: ["click","U","/?q=U","OpenUser","_blank"]
+            if len(parts) >= 5:
+                node_name = parts[1]   # e.g. U
+                old_url   = parts[2]   # e.g. /?q=U
+                middle    = parts[3]   # e.g. OpenUser
+                target    = parts[4]   # e.g. _blank
+
+                # inject base
                 new_url = inject_base_url(old_url)
-                # 2) model param
+                # append model if chosen
                 new_url = append_model_param(new_url, model_selected)
-
-                # Rebuild the line
-                new_line = f"{parts[0]}\"{new_url}\" \"{tooltip}\" {target}"
-                # If there's a remainder (parts[4]) it might be an empty string
-                if len(parts) > 4:
-                    new_line += parts[4]
+                # reassemble line
+                # e.g. "click U <BASEURL> OpenUser _blank"
+                new_line = f"click {node_name} {new_url} {middle} {target}"
                 new_lines.append(new_line)
             else:
                 new_lines.append(line)
@@ -594,64 +493,25 @@ def main():
             new_lines.append(line)
 
     final_mermaid = "\n".join(new_lines)
-    adjacency = parse_mermaid_edges(final_mermaid)
-
-    # 4) If user clicked a shape => we show a partial subgraph as "SearchResult"
-    partial_subgraph_html = ""
-    if q_or_query:
-        # Special-case if user clicked "User" => q=U => we know the node is "U((User 😎))"
-        if q_or_query == "U":
-            chosen_node = "U((User 😎))"
-            st.info(f"process_text called with: {PromptPrefix}{q_or_query}  => forcing node U((User 😎))")
-        else:
-            st.info(f"process_text called with: {PromptPrefix}{q_or_query}")
-            # Attempt to find a node whose ID or label includes q_or_query:
-            possible_keys = []
-            for nodeKey in adjacency.keys():
-                # e.g. nodeKey might be 'U((User 😎))'
-                simplified_key = nodeKey.replace("\\n", " ").replace("[", "").replace("]", "").lower()
-                simplified_query = q_or_query.lower().replace("%20", " ")
-                if simplified_query in simplified_key:
-                    possible_keys.append(nodeKey)
-
-            if possible_keys:
-                chosen_node = possible_keys[0]
-            else:
-                chosen_node = None
-                st.warning("No adjacency node matched the query param's text. Subgraph is empty.")
-
-        if chosen_node:
-            # BFS subgraph for chosen_node with depth=1
-            sub_edges = bfs_subgraph(adjacency, chosen_node, depth=1)
-            sub_mermaid = create_subgraph_mermaid(sub_edges, chosen_node)
-            partial_subgraph_html = generate_mermaid_html(sub_mermaid)
-
-    # 5) Show partial subgraph top-center if we have any
-    if partial_subgraph_html:
-        st.subheader("SearchResult Subgraph")
-        components.html(partial_subgraph_html, height=300, scrolling=False)
-
-    # 6) Render the top-centered *full* diagram
-    st.title("Full Mermaid Diagram (with Base URL + model=1 logic)")
 
+    # 4) Render the top-centered diagram
+    st.title("Mermaid Diagram - No Double Quotes & 'OpenUser'-style Links")
     diagram_html = generate_mermaid_html(final_mermaid)
     components.html(diagram_html, height=400, scrolling=True)
 
-    # 7) Editor columns: Markdown & Mermaid
+    # 5) Two-column interface: Markdown & (final) Mermaid
     left_col, right_col = st.columns(2)
 
     with left_col:
         st.subheader("Markdown Side 📝")
         if "markdown_text" not in st.session_state:
             st.session_state["markdown_text"] = "## Hello!\nYou can type some *Markdown* here.\n"
-        markdown_text = st.text_area(
-            "Edit Markdown:",
-            value=st.session_state["markdown_text"],
-            height=300
-        )
+
+        markdown_text = st.text_area("Edit Markdown:",
+                                     value=st.session_state["markdown_text"],
+                                     height=300)
         st.session_state["markdown_text"] = markdown_text
 
-        # Buttons
         colA, colB = st.columns(2)
         with colA:
             if st.button("🔄 Refresh Markdown"):
@@ -667,15 +527,14 @@ def main():
 
     with right_col:
         st.subheader("Mermaid Side 🧜‍♂️")
+
         if "current_mermaid" not in st.session_state:
             st.session_state["current_mermaid"] = final_mermaid
 
-        # Let user see the final code we built
-        mermaid_input = st.text_area(
-            "Edit Mermaid Code:",
-            value=st.session_state["current_mermaid"],
-            height=300
-        )
+        mermaid_input = st.text_area("Edit Mermaid Code:",
+                                     value=st.session_state["current_mermaid"],
+                                     height=300)
+
         colC, colD = st.columns(2)
         with colC:
             if st.button("🎨 Refresh Diagram"):
@@ -691,27 +550,20 @@ def main():
         st.markdown("**Mermaid Source:**")
         st.code(mermaid_input, language="python", line_numbers=True)
 
-    # 8) Show the galleries
+    # 6) Media Galleries
     st.markdown("---")
     st.header("Media Galleries")
+
     num_columns_images = st.slider("Choose Number of Image Columns", 1, 15, 5, key="num_columns_images")
     display_images_and_wikipedia_summaries(num_columns_images)
 
     num_columns_video = st.slider("Choose Number of Video Columns", 1, 15, 5, key="num_columns_video")
     display_videos_and_links(num_columns_video)
 
-    # 9) Possibly show extended text interface
-    showExtendedTextInterface = False
-    if showExtendedTextInterface:
-        # e.g. display_glossary_grid(roleplaying_glossary)
-        # num_columns_text = st.slider("Choose Number of Text Columns", 1, 15, 4)
-        # display_buttons_with_scores(num_columns_text)
-        pass
-
-    # 10) Render the file sidebar
+    # 7) File Sidebar
     FileSidebar()
 
-    # 11) Random title at bottom
+    # 8) Random Title at bottom
     titles = [
         "🧠🎭 Semantic Symphonies & Episodic Encores",
         "🌌🎼 AI Rhythms of Memory Lane",
@@ -724,6 +576,7 @@ def main():
     ]
     st.markdown(f"**{random.choice(titles)}**")
 
+# End of main
 
 if __name__ == "__main__":
     main()