Update app.py

app.py

@@ -1,36 +1,40 @@
 # app.py
 # =============================================================================
-# ───────────── IMPORTS ─────────────
-# =============================================================================
-import base64
-import glob
-import hashlib
-import json
-import os
-import pandas as pd
-import pytz
-import random
-import re
-import shutil
-import streamlit as st
-import time
-import traceback
-import uuid
-import zipfile
-from PIL import Image
-from azure.cosmos import CosmosClient, PartitionKey, exceptions
-from datetime import datetime
-from git import Repo
-from github import Github
-from gradio_client import Client, handle_file
-import tempfile
-import io
-import requests
-import numpy as np
-from urllib.parse import quote
-
-# =============================================================================
-# ───────────── EXTERNAL HELP LINKS (Always visible in sidebar) ─────────────
+# 🚀 IMPORTS
+# =============================================================================
+import base64  # 🔥 For encoding/decoding files
+import glob  # 🔍 For file searching
+import hashlib  # 🔒 For hashing
+import json  # 🧮 For JSON handling
+import os  # 📁 For OS interactions
+import pandas as pd  # 🐼 For data frame support
+import pytz  # ⏰ For timezone management
+import random  # 🎲 For randomness
+import re  # 🔍 For regex operations
+import shutil  # 🗑️ For file copying/removal
+import streamlit as st  # 💻 For the Streamlit UI
+import time  # ⏳ For timing
+import traceback  # 🚨 For error traces
+import uuid  # 🆔 For unique ID generation
+import zipfile  # 📦 For archiving files
+from PIL import Image  # 🖼️ For image processing
+from azure.cosmos import CosmosClient, PartitionKey, exceptions  # ☁️ For Cosmos DB operations
+from datetime import datetime  # ⏰ For timestamps
+from git import Repo  # 🐙 For Git operations
+from github import Github  # 🔗 For GitHub API interactions
+from gradio_client import Client, handle_file  # 🤖 For Gradio video generation
+import tempfile  # 📝 For temporary file handling
+import io  # 📡 For in-memory streams
+import requests  # 🌐 For HTTP requests
+import numpy as np  # 🔢 For numerical operations
+from urllib.parse import quote  # 🔗 For URL encoding
+
+# Allow nested asyncio.run calls (needed for our async TTS and Arxiv search)
+import nest_asyncio
+nest_asyncio.apply()
+
+# =============================================================================
+# 😎 EXTERNAL HELP LINKS (Always visible in sidebar)
 # =============================================================================
 external_links = [
     {"title": "MergeKit Official GitHub", "url": "https://github.com/arcee-ai/MergeKit", "emoji": "💻"},
@@ -46,7 +50,7 @@ external_links = [
 ]
 
 # =============================================================================
-# ───────────── APP CONFIGURATION ─────────────
+# 🎨 APP CONFIGURATION
 # =============================================================================
 Site_Name = '🐙 GitCosmos'
 title = "🐙 GitCosmos"
@@ -74,8 +78,9 @@ LOCAL_APP_URL = "https://huggingface.co/spaces/awacke1/AzureCosmosDBUI"
 CosmosDBUrl = 'https://portal.azure.com/#@AaronCWackergmail.onmicrosoft.com/resource/subscriptions/003fba60-5b3f-48f4-ab36-3ed11bc40816/resourceGroups/datasets/providers/Microsoft.DocumentDB/databaseAccounts/acae-afd/dataExplorer'
 
 # =============================================================================
-# ───────────── HELPER FUNCTIONS ─────────────
+# 💾 HELPER FUNCTIONS
 # =============================================================================
+# 🔗 Get a download link for a file
 def get_download_link(file_path):
     with open(file_path, "rb") as file:
         contents = file.read()
@@ -83,6 +88,7 @@ def get_download_link(file_path):
         file_name = os.path.basename(file_path)
         return f'<a href="data:file/txt;base64,{b64}" download="{file_name}">Download {file_name} 📂</a>'
 
+# 🆔 Generate a unique ID
 def generate_unique_id():
     timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
     unique_uuid = str(uuid.uuid4())
@@ -90,23 +96,27 @@ def generate_unique_id():
     st.write('New ID: ' + return_value)
     return return_value
 
+# 📝 Generate a safe filename based on a prompt
 def generate_filename(prompt, file_type):
     central = pytz.timezone('US/Central')
     safe_date_time = datetime.now(central).strftime("%m%d_%H%M")
     safe_prompt = re.sub(r'\W+', '', prompt)[:90]
     return f"{safe_date_time}{safe_prompt}.{file_type}"
 
+# 📄 Create a file with given content
 def create_file(filename, prompt, response, should_save=True):
     if not should_save:
         return
     with open(filename, 'w', encoding='utf-8') as file:
         file.write(prompt + "\n\n" + response)
 
+# 📂 Load file contents
 def load_file(file_name):
     with open(file_name, "r", encoding='utf-8') as file:
         content = file.read()
     return content
 
+# 🔗 Display a glossary entity with quick search links
 def display_glossary_entity(k):
     search_urls = {
         "🚀": lambda k: f"/?q={k}",
@@ -117,6 +127,7 @@ def display_glossary_entity(k):
     links_md = ' '.join([f"<a href='{url(k)}' target='_blank'>{emoji}</a>" for emoji, url in search_urls.items()])
     st.markdown(f"{k} {links_md}", unsafe_allow_html=True)
 
+# 📦 Create a ZIP archive of given files
 def create_zip_of_files(files):
     zip_name = "all_files.zip"
     with zipfile.ZipFile(zip_name, 'w') as zipf:
@@ -124,6 +135,7 @@ def create_zip_of_files(files):
             zipf.write(file)
     return zip_name
 
+# 🎥 Get HTML to embed a video
 def get_video_html(video_path, width="100%"):
     video_url = f"data:video/mp4;base64,{base64.b64encode(open(video_path, 'rb').read()).decode()}"
     return f'''
@@ -133,6 +145,7 @@ def get_video_html(video_path, width="100%"):
     </video>
     '''
 
+# 🎵 Get HTML to embed audio
 def get_audio_html(audio_path, width="100%"):
     audio_url = f"data:audio/mpeg;base64,{base64.b64encode(open(audio_path, 'rb').read()).decode()}"
     return f'''
@@ -142,6 +155,7 @@ def get_audio_html(audio_path, width="100%"):
     </audio>
     '''
 
+# ✂️ Preprocess text (e.g., for JSON safety)
 def preprocess_text(text):
     text = text.replace('\r\n', '\\n').replace('\r', '\\n').replace('\n', '\\n')
     text = text.replace('"', '\\"')
@@ -150,7 +164,7 @@ def preprocess_text(text):
     return text.strip()
 
 # =============================================================================
-# ───────────── COSMOS DB FUNCTIONS ─────────────
+# ☁️ COSMOS DB FUNCTIONS
 # =============================================================================
 def get_databases(client):
     return [db['id'] for db in client.list_databases()]
@@ -255,7 +269,7 @@ def archive_current_container(database_name, container_name, client):
         return f"Archive error: {str(e)} 😢"
 
 # =============================================================================
-# ───────────── ADVANCED COSMOS FUNCTIONS ─────────────
+# 🚀 ADVANCED COSMOS FUNCTIONS
 # =============================================================================
 def create_new_container(database, container_id, partition_key_path,
                          analytical_storage_ttl=None, indexing_policy=None, vector_embedding_policy=None):
@@ -324,7 +338,7 @@ def vector_search(container, query_vector, vector_field, top=10, exact_search=Fa
     return results
 
 # =============================================================================
-# ───────────── GITHUB FUNCTIONS ─────────────
+# 🐙 GITHUB FUNCTIONS
 # =============================================================================
 def download_github_repo(url, local_path):
     if os.path.exists(local_path):
@@ -357,7 +371,7 @@ def push_to_github(local_path, repo, github_token):
     origin.push(refspec=f'{current_branch}:{current_branch}')
 
 # =============================================================================
-# ───────────── FILE & MEDIA MANAGEMENT FUNCTIONS ─────────────
+# 📁 FILE & MEDIA MANAGEMENT FUNCTIONS
 # =============================================================================
 def display_saved_files_in_sidebar():
     all_files = sorted([f for f in glob.glob("*.md") if not f.lower().startswith('readme')], reverse=True)
@@ -399,11 +413,7 @@ def display_file_editor(file_path):
             return
     st.markdown("### ✏️ Edit File")
     st.markdown(f"**Editing:** {file_path}")
-    md_tab, code_tab = st.tabs(["Markdown", "Code"])
-    with md_tab:
-        st.markdown(st.session_state.file_content[file_path])
-    with code_tab:
-        new_content = st.text_area("Edit:", value=st.session_state.file_content[file_path], height=400, key=f"editor_{hash(file_path)}")
+    new_content = st.text_area("Edit JSON", value=st.session_state.file_content[file_path], height=400, key="doc_editor", on_change=lambda: auto_save_edit())
     col1, col2 = st.columns([1, 5])
     with col1:
         if st.button("💾 Save"):
@@ -474,12 +484,10 @@ def update_file_management_section():
                     st.session_state.current_file = None
                     st.session_state.file_view_mode = None
                 st.rerun()
-                
     st.sidebar.markdown("---")
     st.sidebar.title("External Help Links")
     for link in external_links:
         st.sidebar.markdown(f"{link['emoji']} [{link['title']}]({link['url']})", unsafe_allow_html=True)
-       
     if st.session_state.current_file:
         if st.session_state.file_view_mode == 'view':
             display_file_viewer(st.session_state.current_file)
@@ -487,7 +495,34 @@ def update_file_management_section():
             display_file_editor(st.session_state.current_file)
 
 # =============================================================================
-# ───────────── VIDEO & AUDIO UI FUNCTIONS ─────────────
+# ✨ SIDEBAR DATA GRID: Show all container records with formatted timestamp
+# =============================================================================
+def show_sidebar_data_grid(container):
+    try:
+        records = get_documents(container)
+        # Build list of dicts with desired columns; sort descending by _ts or timestamp field
+        data = []
+        for rec in records:
+            ts = rec.get("timestamp", "")
+            try:
+                dt = datetime.fromisoformat(ts)
+                formatted = dt.strftime("%I:%M %p %m/%d/%Y")
+            except Exception:
+                formatted = ts
+            data.append({
+                "ID": rec.get("id", ""),
+                "Name": rec.get("name", ""),
+                "Timestamp": formatted
+            })
+        df = pd.DataFrame(data)
+        # Already sorted by _ts descending from the query; display in sidebar
+        st.sidebar.markdown("### 📊 Data Grid")
+        st.sidebar.dataframe(df)
+    except Exception as e:
+        st.sidebar.error(f"Data grid error: {str(e)}")
+
+# =============================================================================
+# 🎥 VIDEO & AUDIO UI FUNCTIONS
 # =============================================================================
 def validate_and_preprocess_image(file_data, target_size=(576, 1024)):
     try:
@@ -603,345 +638,616 @@ def add_video_generation_ui(container):
             st.error(f"Upload error: {str(e)}")
 
 # =============================================================================
-# ───────────── AI SAMPLES SIDEBAR (Processed as a Python List) ─────────────
-# =============================================================================
-def display_ai_samples():
-    # Define a list of sample queries
-    ai_samples = [
-        {
-            "name": "FullTextContains",
-            "description": "Query using FullTextContains",
-            "query": 'SELECT TOP 10 * FROM c WHERE FullTextContains(c.text, "bicycle")'
-        },
-        {
-            "name": "FullTextContainsAll",
-            "description": "Query using FullTextContainsAll",
-            "query": 'SELECT TOP 10 * FROM c WHERE FullTextContainsAll(c.text, "red", "bicycle")'
-        },
-        {
-            "name": "FullTextContainsAny",
-            "description": "Query using FullTextContainsAny",
-            "query": 'SELECT TOP 10 * FROM c WHERE FullTextContains(c.text, "red") AND FullTextContainsAny(c.text, "bicycle", "skateboard")'
-        },
-        {
-            "name": "FullTextScore",
-            "description": "Query using FullTextScore (order by relevance)",
-            "query": 'SELECT TOP 10 * FROM c ORDER BY RANK FullTextScore(c.text, ["bicycle", "mountain"])'
-        },
-        {
-            "name": "Vector Search with Score",
-            "description": "Example vector search snippet",
-            "query": 'results = vector_search.similarity_search_with_score(query="Your query", k=5)\nfor result, score in results:\n    print(result.json(), score)'
-        },
-        {
-            "name": "Vector Search with Filtering",
-            "description": "Example vector search with a filter",
-            "query": 'pre_filter = {"conditions": [{"property": "metadata.page", "operator": "$eq", "value": 0}]}\nresults = vector_search.similarity_search_with_score(query="Your query", k=5, pre_filter=pre_filter)'
-        },
-        {
-            "name": "Hybrid Search",
-            "description": "Example hybrid search snippet",
-            "query": 'results = vector_search.similarity_search_with_score(query="Your query", k=5, query_type=CosmosDBQueryType.HYBRID)'
-        }
+# 🤖 NEW ITEM & FIELD FUNCTIONS
+# =============================================================================
+def new_item_default(container):
+    new_id = generate_unique_id()
+    default_doc = {
+         "id": new_id,
+         "pk": new_id,
+         "name": "New Sample Document",
+         "content": "Start editing your document here...",
+         "timestamp": datetime.now().isoformat(),
+         "type": "sample"
+    }
+    success, message = insert_record(container, default_doc)
+    if success:
+         st.success("New sample document created! ✨")
+         return default_doc
+    else:
+         st.error("Error creating new item: " + message)
+         return None
+
+def auto_save_edit():
+    try:
+         edited_str = st.session_state.doc_editor
+         edited_doc = json.loads(edited_str)
+         container = st.session_state.current_container
+         container.upsert_item(edited_doc)
+         st.success("Auto-saved! 💾")
+    except Exception as e:
+         st.error(f"Auto-save error: {str(e)}")
+
+def add_field_to_doc():
+    key = st.session_state.new_field_key
+    value = st.session_state.new_field_value
+    try:
+         doc = json.loads(st.session_state.doc_editor)
+         doc[key] = value
+         st.session_state.doc_editor = json.dumps(doc, indent=2)
+         auto_save_edit()
+         st.success(f"Added field {key} 👍")
+    except Exception as e:
+         st.error(f"Error adding field: {str(e)}")
+
+# =============================================================================
+# 🔍 VECTOR SEARCH INTERFACE (Simple keyword search)
+# =============================================================================
+def vector_keyword_search(keyword, container):
+    try:
+        query = f"SELECT * FROM c WHERE CONTAINS(c.content, '{keyword}')"
+        results = list(container.query_items(query=query, enable_cross_partition_query=True))
+        return results
+    except Exception as e:
+        st.error(f"Vector search error: {str(e)}")
+        return []
+
+# =============================================================================
+# 🤖 NEW AI MODALITY RECORD TEMPLATES
+# =============================================================================
+def new_ai_record(container):
+    new_id = generate_unique_id()
+    default_doc = {
+        "id": new_id,
+        "pk": new_id,
+        "name": "AI Modality Record",
+        "function_url": "https://example.com/function",
+        "input_text": "### Input (markdown)\n\nType your input here.",
+        "output_text": "### Output (markdown)\n\nResult will appear here.",
+        "timestamp": datetime.now().isoformat(),
+        "type": "ai_modality"
+    }
+    success, message = insert_record(container, default_doc)
+    if success:
+         st.success("New AI modality record created! 💡")
+         return default_doc
+    else:
+         st.error("Error creating AI record: " + message)
+         return None
+
+def new_links_record(container):
+    new_id = generate_unique_id()
+    links_md = "\n".join([f"- {link['emoji']} [{link['title']}]({link['url']})" for link in external_links])
+    default_doc = {
+         "id": new_id,
+         "pk": new_id,
+         "name": "Portal Links Record",
+         "function_url": "",
+         "input_text": links_md,
+         "output_text": "",
+         "timestamp": datetime.now().isoformat(),
+         "type": "ai_modality"
+    }
+    success, message = insert_record(container, default_doc)
+    if success:
+         st.success("New Portal Links record created! 🔗")
+         return default_doc
+    else:
+         st.error("Error creating links record: " + message)
+         return None
+
+# =============================================================================
+# 🤖 LANGCHAIN FUNCTIONS (Witty emoji comments)
+# =============================================================================
+def display_langchain_functions():
+    functions = [
+       {"name": "OpenAIEmbeddings", "comment": "🔮 Creates embeddings using OpenAI – pure magic!"},
+       {"name": "AzureCosmosDBNoSqlVectorSearch", "comment": "🚀 Performs vector search on Cosmos DB – superfast and smart!"},
+       {"name": "RecursiveCharacterTextSplitter", "comment": "✂️ Slices text into manageable chunks – like a pro chef!"}
     ]
-    st.sidebar.markdown("### 🤖 AI Samples")
-    st.sidebar.info("🚀 Get started with our AI samples! Time free access to get started today.")
-    # Provide a dropdown to select one sample
-    sample_names = [sample["name"] for sample in ai_samples]
-    selected_sample_name = st.sidebar.selectbox("Select an AI Sample", sample_names)
-    selected_sample = next((s for s in ai_samples if s["name"] == selected_sample_name), None)
-    if selected_sample:
-        st.sidebar.markdown(f"**{selected_sample['name']}**: {selected_sample['description']}")
-        # Use language 'sql' for queries containing FullText, else python
-        lang = "sql" if "FullText" in selected_sample["name"] else "python"
-        st.sidebar.code(selected_sample["query"], language=lang)
+    st.sidebar.markdown("### 🤖 Langchain Functions")
+    for func in functions:
+        st.sidebar.write(f"{func['name']}: {func['comment']}")
+
+# =============================================================================
+# ─────────────────────────────────────────────────────────
+# NEW: SIDEBAR DATA GRID FUNCTION
+# =============================================================================
+def show_sidebar_data_grid():
+    if st.session_state.get("current_container"):
+        show_sidebar_data_grid.container = st.session_state.current_container
+        try:
+            records = get_documents(show_sidebar_data_grid.container)
+            data = []
+            for rec in records:
+                ts = rec.get("timestamp", "")
+                try:
+                    dt = datetime.fromisoformat(ts)
+                    formatted = dt.strftime("%I:%M %p %m/%d/%Y")
+                except Exception:
+                    formatted = ts
+                data.append({
+                    "ID": rec.get("id", ""),
+                    "Name": rec.get("name", ""),
+                    "Timestamp": formatted
+                })
+            df = pd.DataFrame(data)
+            st.sidebar.markdown("### 📊 Data Grid")
+            st.sidebar.dataframe(df)
+        except Exception as e:
+            st.sidebar.error(f"Data grid error: {str(e)}")
+    else:
+        st.sidebar.info("No container selected for data grid.")
+
+# =============================================================================
+# 🤖 RESEARCH / ARXIV FUNCTIONS (Copied from second app code)
+# =============================================================================
+def parse_arxiv_refs(ref_text: str):
+    if not ref_text:
+        return []
+    results = []
+    current_paper = {}
+    lines = ref_text.split('\n')
+    for i, line in enumerate(lines):
+        if line.count('|') == 2:
+            if current_paper:
+                results.append(current_paper)
+                if len(results) >= 20:
+                    break
+            try:
+                header_parts = line.strip('* ').split('|')
+                date = header_parts[0].strip()
+                title = header_parts[1].strip()
+                url_match = re.search(r'(https://arxiv.org/\S+)', line)
+                url = url_match.group(1) if url_match else f"paper_{len(results)}"
+                current_paper = {
+                    'date': date,
+                    'title': title,
+                    'url': url,
+                    'authors': '',
+                    'summary': '',
+                    'full_audio': None,
+                    'download_base64': '',
+                }
+            except Exception as e:
+                st.warning(f"Error parsing paper header: {str(e)}")
+                current_paper = {}
+                continue
+        elif current_paper:
+            if not current_paper['authors']:
+                current_paper['authors'] = line.strip('* ')
+            else:
+                if current_paper['summary']:
+                    current_paper['summary'] += ' ' + line.strip()
+                else:
+                    current_paper['summary'] = line.strip()
+    if current_paper:
+        results.append(current_paper)
+    return results[:20]
+
+def create_paper_links_md(papers):
+    lines = ["# Paper Links\n"]
+    for i, p in enumerate(papers, start=1):
+        lines.append(f"{i}. **{p['title']}** — [Arxiv Link]({p['url']})")
+    return "\n".join(lines)
+
+def generate_pdf_link(url: str) -> str:
+    if "abs" in url:
+        pdf_url = url.replace("abs", "pdf")
+        if not pdf_url.endswith(".pdf"):
+            pdf_url += ".pdf"
+        return pdf_url
+    return url
+
+def generate_5min_feature_markdown(paper: dict) -> str:
+    title = paper.get('title', '')
+    summary = paper.get('summary', '')
+    authors = paper.get('authors', '')
+    date = paper.get('date', '')
+    url = paper.get('url', '')
+    pdf_link = generate_pdf_link(url)
+    title_wc = len(title.split())
+    summary_wc = len(summary.split())
+    high_info_terms = [term for term in summary.split()[:5]]  # simplified for demo
+    terms_str = ", ".join(high_info_terms)
+    rouge_score = round((len(high_info_terms) / max(len(summary.split()), 1)) * 100, 2)
+    mermaid_code = "```mermaid\nflowchart TD\n"
+    for i in range(len(high_info_terms) - 1):
+        mermaid_code += f'    T{i+1}["{high_info_terms[i]}"] --> T{i+2}["{high_info_terms[i+1]}"]\n'
+    mermaid_code += "```"
+    md = f"""
+## {title}
+
+**Authors:** {authors}  
+**Date:** {date}  
+**Word Count (Title):** {title_wc} | **Word Count (Summary):** {summary_wc}  
+
+**Links:** [Abstract]({url}) | [PDF]({pdf_link})
+
+**High Info Terms:** {terms_str}  
+**ROUGE Score:** {rouge_score}%
+
+### Mermaid Graph of Key Concepts
+{mermaid_code}
+
+---
+"""
+    return md
+
+def create_detailed_paper_md(papers: list) -> str:
+    md_parts = ["# Detailed Research Paper Summary\n"]
+    for idx, paper in enumerate(papers, start=1):
+        md_parts.append(generate_5min_feature_markdown(paper))
+    return "\n".join(md_parts)
 
 # =============================================================================
-# ───────────── MAIN FUNCTION ─────────────
+# 🤖 ASYNC TTS FUNCTIONS (from second app code)
+# =============================================================================
+import asyncio
+import edge_tts
+from streamlit_marquee import streamlit_marquee
+from collections import Counter
+
+class PerformanceTimer:
+    def __init__(self, operation_name: str):
+        self.operation_name = operation_name
+        self.start_time = None
+    def __enter__(self):
+        self.start_time = time.time()
+        return self
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+async def async_edge_tts_generate(text: str, voice: str, rate: int = 0, pitch: int = 0, file_format: str = "mp3"):
+    with PerformanceTimer("tts_generation") as timer:
+        text = text.replace("\n", " ").strip()
+        if not text:
+            return None, 0
+        cache_key = f"{text[:100]}_{voice}_{rate}_{pitch}_{file_format}"
+        if cache_key in st.session_state.get('audio_cache', {}):
+            return st.session_state['audio_cache'][cache_key], 0
+        try:
+            rate_str = f"{rate:+d}%"
+            pitch_str = f"{pitch:+d}Hz"
+            communicate = edge_tts.Communicate(text, voice, rate=rate_str, pitch=pitch_str)
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"audio_{timestamp}_{random.randint(1000, 9999)}.{file_format}"
+            await communicate.save(filename)
+            st.session_state.setdefault('audio_cache', {})[cache_key] = filename
+            return filename, time.time() - timer.start_time
+        except Exception as e:
+            st.error(f"Error generating audio: {str(e)}")
+            return None, 0
+
+def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0, file_format="mp3"):
+    result = asyncio.run(async_edge_tts_generate(text, voice, rate, pitch, file_format))
+    if isinstance(result, tuple):
+        return result[0]
+    return result
+
+async def async_save_qa_with_audio(question: str, answer: str):
+    with PerformanceTimer("qa_save") as timer:
+        md_file = create_file(question, answer, "md")
+        audio_file = None
+        if st.session_state.get('enable_audio', True):
+            audio_text = f"{question}\n\nAnswer: {answer}"
+            audio_file, _ = await async_edge_tts_generate(audio_text, voice=st.session_state.get('tts_voice', "en-US-AriaNeural"), file_format=st.session_state.get('audio_format', "mp3"))
+        return md_file, audio_file, time.time() - timer.start_time, 0
+
+def save_qa_with_audio(question, answer, voice=None):
+    if not voice:
+        voice = st.session_state.get('tts_voice', "en-US-AriaNeural")
+    md_file = create_file(question, answer, "md")
+    audio_text = f"{question}\n\nAnswer: {answer}"
+    audio_file = speak_with_edge_tts(audio_text, voice=voice, file_format=st.session_state.get('audio_format', "mp3"))
+    return md_file, audio_file
+
+def play_and_download_audio(file_path, file_type="mp3"):
+    if file_path and os.path.exists(file_path):
+        st.audio(file_path)
+        dl_link = get_download_link(file_path, file_type=file_type)
+        st.markdown(dl_link, unsafe_allow_html=True)
+
+def create_download_link_with_cache(file_path: str, file_type: str = "mp3") -> str:
+    cache_key = f"dl_{file_path}"
+    if cache_key in st.session_state.get('download_link_cache', {}):
+        return st.session_state['download_link_cache'][cache_key]
+    try:
+        with open(file_path, "rb") as f:
+            b64 = base64.b64encode(f.read()).decode()
+        filename = os.path.basename(file_path)
+        if file_type == "mp3":
+            link = f'<a href="data:audio/mpeg;base64,{b64}" download="{filename}">🎵 Download {filename}</a>'
+        elif file_type == "wav":
+            link = f'<a href="data:audio/wav;base64,{b64}" download="{filename}">🔊 Download {filename}</a>'
+        elif file_type == "md":
+            link = f'<a href="data:text/markdown;base64,{b64}" download="{filename}">📝 Download {filename}</a>'
+        else:
+            link = f'<a href="data:application/octet-stream;base64,{b64}" download="{filename}">Download {filename}</a>'
+        st.session_state.setdefault('download_link_cache', {})[cache_key] = link
+        return link
+    except Exception as e:
+        st.error(f"Error creating download link: {str(e)}")
+        return ""
+
+# =============================================================================
+# ─────────────────────────────────────────────────────────
+# MAIN FUNCTION
 # =============================================================================
 def main():
-    st.markdown("### 🐙 GitCosmos - Cosmos & Git Hub")
+    # Friendly portal link
+    st.markdown(f"[🔗 Portal]({CosmosDBUrl})")
+    # Initialize some session state keys if not already present
     if "chat_history" not in st.session_state:
         st.session_state.chat_history = []
-    # Auth & Cosmos client initialization
-    if Key:
-        st.session_state.primary_key = Key
-        st.session_state.logged_in = True
-    else:
-        st.error("Missing Cosmos Key 🔑❌")
-        return
-    if st.session_state.logged_in:
-        try:
-            if st.session_state.get("client") is None:
-                st.session_state.client = CosmosClient(ENDPOINT, credential=st.session_state.primary_key)
-            st.sidebar.title("🐙 Navigator")
-            databases = get_databases(st.session_state.client)
-            selected_db = st.sidebar.selectbox("🗃️ DB", databases)
-            st.markdown(CosmosDBUrl)
-            if selected_db != st.session_state.get("selected_database"):
-                st.session_state.selected_database = selected_db
-                st.session_state.selected_container = None
+    st.session_state.setdefault("current_container", None)
+    # Sidebar: New Item, Add Field, New AI Record, New Links Record, and Vector Search
+    st.sidebar.markdown("## 🛠️ Item Management")
+    if st.sidebar.button("New Item"):
+        if st.session_state.get("current_container"):
+            new_doc = new_item_default(st.session_state.current_container)
+            if new_doc:
+                st.session_state.doc_editor = json.dumps(new_doc, indent=2)
+        else:
+            st.warning("No container selected!")
+    st.sidebar.text_input("New Field Key", key="new_field_key")
+    st.sidebar.text_input("New Field Value", key="new_field_value")
+    if st.sidebar.button("Add Field"):
+        if "doc_editor" in st.session_state:
+            add_field_to_doc()
+        else:
+            st.warning("No document loaded to add a field.")
+    if st.sidebar.button("New AI Record"):
+        if st.session_state.get("current_container"):
+            new_ai_record(st.session_state.current_container)
+        else:
+            st.warning("No container selected!")
+    if st.sidebar.button("New Links Record"):
+        if st.session_state.get("current_container"):
+            new_links_record(st.session_state.current_container)
+        else:
+            st.warning("No container selected!")
+    st.sidebar.markdown("## 🔍 Vector Search")
+    search_keyword = st.sidebar.text_input("Search Keyword", key="vector_search_keyword")
+    if st.sidebar.button("Search"):
+        if st.session_state.get("current_container"):
+            results = vector_keyword_search(search_keyword, st.session_state.current_container)
+            st.sidebar.write(f"Found {len(results)} results:")
+            for res in results:
+                st.sidebar.code(json.dumps(res, indent=2), language="json")
+        else:
+            st.warning("No container selected for search!")
+    # Show the sidebar data grid with records
+    show_sidebar_data_grid()
+    # Display Langchain functions in sidebar
+    display_langchain_functions()
+    # Navigator: Container selection and data grid
+    try:
+        if st.session_state.get("client") is None:
+            st.session_state.client = CosmosClient(ENDPOINT, credential=st.session_state.primary_key)
+        st.sidebar.title("🐙 Navigator")
+        databases = get_databases(st.session_state.client)
+        selected_db = st.sidebar.selectbox("🗃️ DB", databases)
+        if selected_db != st.session_state.get("selected_database"):
+            st.session_state.selected_database = selected_db
+            st.session_state.selected_container = None
+            st.session_state.selected_document_id = None
+            st.session_state.current_index = 0
+            st.rerun()
+        if st.session_state.selected_database:
+            database = st.session_state.client.get_database_client(st.session_state.selected_database)
+            if "show_new_container_form" not in st.session_state:
+                st.session_state.show_new_container_form = False
+            if st.sidebar.button("🆕 New Container"):
+                st.session_state.show_new_container_form = True
+            if st.session_state.show_new_container_form:
+                with st.sidebar.form("new_container_form"):
+                    new_container_id = st.text_input("Container ID", value="aiml-container")
+                    new_partition_key = st.text_input("Partition Key", value="/pk")
+                    new_analytical = st.checkbox("Enable Analytical Store", value=True)
+                    submitted = st.form_submit_button("Create Container")
+                    if submitted:
+                        analytical_ttl = -1 if new_analytical else None
+                        new_container = create_new_container(
+                            database,
+                            new_container_id,
+                            new_partition_key,
+                            analytical_storage_ttl=analytical_ttl
+                        )
+                        if new_container:
+                            st.success(f"Container '{new_container_id}' created.")
+                            default_id = generate_unique_id()
+                            default_item = {
+                                "id": default_id,
+                                "pk": default_id,
+                                "name": "Default Image Prompt",
+                                "prompt": "Enter your image prompt here",
+                                "timestamp": datetime.now().isoformat(),
+                                "type": "image_prompt"
+                            }
+                            insert_success, insert_message = insert_record(new_container, default_item)
+                            if insert_success:
+                                st.info("Default templated item created in new container.")
+                            else:
+                                st.error(f"Default item insertion error: {insert_message}")
+                            st.session_state.show_new_container_form = False
+                            st.session_state.new_container_created = new_container_id
+                            st.rerun()
+            containers = get_containers(database)
+            if "new_container_created" in st.session_state and st.session_state.new_container_created not in containers:
+                containers.append(st.session_state.new_container_created)
+            selected_container = st.sidebar.selectbox("📁 Container", containers)
+            if selected_container != st.session_state.get("selected_container"):
+                st.session_state.selected_container = selected_container
                 st.session_state.selected_document_id = None
                 st.session_state.current_index = 0
                 st.rerun()
-            if st.session_state.selected_database:
-                database = st.session_state.client.get_database_client(st.session_state.selected_database)
-                
-                # New Container button under DB menu
-                if "show_new_container_form" not in st.session_state:
-                    st.session_state.show_new_container_form = False
-                if st.sidebar.button("🆕 New Container"):
-                    st.session_state.show_new_container_form = True
-                if st.session_state.show_new_container_form:
-                    with st.sidebar.form("new_container_form"):
-                        new_container_id = st.text_input("Container ID", value="aiml-container")
-                        new_partition_key = st.text_input("Partition Key", value="/pk")
-                        new_analytical = st.checkbox("Enable Analytical Store", value=True)
-                        submitted = st.form_submit_button("Create Container")
-                        if submitted:
-                            analytical_ttl = -1 if new_analytical else None
-                            new_container = create_new_container(
-                                database,
-                                new_container_id,
-                                new_partition_key,
-                                analytical_storage_ttl=analytical_ttl
-                            )
-                            if new_container:
-                                st.success(f"Container '{new_container_id}' created.")
-                                # Insert a default templated item into the new container
-                                default_id = generate_unique_id()
-                                default_item = {
-                                    "id": default_id,
-                                    "pk": default_id,
-                                    "name": "Default Image Prompt",
-                                    "prompt": "Enter your image prompt here",
-                                    "timestamp": datetime.now().isoformat(),
-                                    "type": "image_prompt"
-                                }
-                                insert_success, insert_message = insert_record(new_container, default_item)
-                                if insert_success:
-                                    st.info("Default templated item created in new container.")
-                                else:
-                                    st.error(f"Default item insertion error: {insert_message}")
-                                st.session_state.show_new_container_form = False
-                                st.session_state.new_container_created = new_container_id
+            if st.session_state.selected_container:
+                container = database.get_container_client(st.session_state.selected_container)
+                st.session_state.current_container = container
+                if st.sidebar.button("📦 Export"):
+                    download_link = archive_current_container(st.session_state.selected_database, st.session_state.selected_container, st.session_state.client)
+                    if download_link.startswith('<a'):
+                        st.markdown(download_link, unsafe_allow_html=True)
+                    else:
+                        st.error(download_link)
+                documents = get_documents(container)
+                total_docs = len(documents)
+                num_docs = st.slider("Docs", 1, 20, 1)
+                documents_to_display = documents[:num_docs] if total_docs > num_docs else documents
+                st.sidebar.info(f"Showing {len(documents_to_display)} docs")
+                view_options = ['Markdown', 'Code', 'Run AI', 'Clone', 'New']
+                selected_view = st.sidebar.selectbox("View", view_options, index=1)
+                if selected_view == 'Markdown':
+                    st.markdown("#### 📄 Markdown")
+                    if documents:
+                        doc = documents[st.session_state.current_index]
+                        content = json.dumps(doc, indent=2)
+                        st.markdown(f"```json\n{content}\n```")
+                        col_prev, col_next = st.columns(2)
+                        with col_prev:
+                            if st.button("⬅️") and st.session_state.current_index > 0:
+                                st.session_state.current_index -= 1
                                 st.rerun()
-                
-                # Update container list
-                containers = get_containers(database)
-                if "new_container_created" in st.session_state and st.session_state.new_container_created not in containers:
-                    containers.append(st.session_state.new_container_created)
-                selected_container = st.sidebar.selectbox("📁 Container", containers)
-                if selected_container != st.session_state.get("selected_container"):
-                    st.session_state.selected_container = selected_container
-                    st.session_state.selected_document_id = None
-                    st.session_state.current_index = 0
-                    st.rerun()
-                if st.session_state.selected_container:
-                    container = database.get_container_client(st.session_state.selected_container)
-                    if st.sidebar.button("📦 Export"):
-                        download_link = archive_current_container(st.session_state.selected_database, st.session_state.selected_container, st.session_state.client)
-                        if download_link.startswith('<a'):
-                            st.markdown(download_link, unsafe_allow_html=True)
-                        else:
-                            st.error(download_link)
-                    documents = get_documents(container)
-                    total_docs = len(documents)
-                    num_docs = st.slider("Docs", 1, 20, 1)
-                    documents_to_display = documents[:num_docs] if total_docs > num_docs else documents
-                    st.sidebar.info(f"Showing {len(documents_to_display)} docs")
-                    # Document Viewer / Editor
-                    view_options = ['Markdown', 'Code', 'Run AI', 'Clone', 'New']
-                    selected_view = st.sidebar.selectbox("View", view_options, index=1)
-                    if selected_view == 'Markdown':
-                        st.markdown("#### 📄 Markdown")
-                        if documents:
-                            doc = documents[st.session_state.current_index]
-                            content = json.dumps(doc, indent=2)
-                            st.markdown(f"```json\n{content}\n```")
-                            col_prev, col_next = st.columns(2)
-                            with col_prev:
-                                if st.button("⬅️") and st.session_state.current_index > 0:
-                                    st.session_state.current_index -= 1
-                                    st.rerun()
-                            with col_next:
-                                if st.button("➡️") and st.session_state.current_index < total_docs - 1:
-                                    st.session_state.current_index += 1
-                                    st.rerun()
-                    elif selected_view == 'Code':
-                        st.markdown("#### 💻 Code Editor")
-                        if documents:
-                            doc = documents[st.session_state.current_index]
-                            doc_str = st.text_area("Edit JSON", value=json.dumps(doc, indent=2), height=300, key=f'code_{st.session_state.current_index}')
-                            col_prev, col_next = st.columns(2)
-                            with col_prev:
-                                if st.button("⬅️") and st.session_state.current_index > 0:
-                                    st.session_state.current_index -= 1
-                                    st.rerun()
-                            with col_next:
-                                if st.button("➡️") and st.session_state.current_index < total_docs - 1:
-                                    st.session_state.current_index += 1
-                                    st.rerun()
-                            col_save, col_delete = st.columns(2)
-                            with col_save:
-                                if st.button("💾 Save", key=f'save_{st.session_state.current_index}'):
-                                    try:
-                                        updated_doc = json.loads(doc_str)
-                                        container.upsert_item(body=updated_doc)
-                                        st.success(f"Saved {updated_doc['id']}")
-                                        st.rerun()
-                                    except Exception as e:
-                                        st.error(f"Save err: {str(e)}")
-                            with col_delete:
-                                if st.button("🗑️ Delete", key=f'delete_{st.session_state.current_index}'):
-                                    try:
-                                        current_doc = json.loads(doc_str)
-                                        success, message = delete_record(container, current_doc)
-                                        if success:
-                                            st.success(message)
-                                            st.rerun()
-                                        else:
-                                            st.error(message)
-                                    except Exception as e:
-                                        st.error(f"Delete err: {str(e)}")
-                            if "delete_log" in st.session_state and st.session_state.delete_log:
-                                st.subheader("Delete Log")
-                                for log_entry in st.session_state.delete_log[-5:]:
-                                    st.write(log_entry)
-                    elif selected_view == 'Run AI':
-                        st.markdown("#### 🤖 Run AI (stub)")
-                        st.info("AI functionality not implemented.")
-                    elif selected_view == 'Clone':
-                        st.markdown("#### 📄 Clone")
-                        if documents:
-                            doc = documents[st.session_state.current_index]
-                            st.markdown(f"Original ID: {doc.get('id', '')}")
-                            new_id = st.text_input("New ID", value=generate_unique_id(), key='new_clone_id')
-                            new_name = st.text_input("New Name", value=f"Clone_{new_id[:8]}", key='new_clone_name')
-                            new_doc = {'id': new_id, 'pk': new_id, 'name': new_name, **{k: v for k, v in doc.items() if k not in ['id', 'name', 'pk', '_rid', '_self', '_etag', '_attachments', '_ts']}}
-                            doc_str = st.text_area("Edit JSON", value=json.dumps(new_doc, indent=2), height=300, key='clone_preview')
-                            col1, col2 = st.columns(2)
-                            with col1:
-                                if st.button("🔄 Regenerate"):
-                                    new_id = generate_unique_id()
-                                    st.session_state.new_clone_id = new_id
-                                    st.rerun()
-                            with col2:
-                                if st.button("💾 Save Clone"):
-                                    try:
-                                        final_doc = json.loads(doc_str)
-                                        for field in ['_rid', '_self', '_etag', '_attachments', '_ts']:
-                                            final_doc.pop(field, None)
-                                        container.create_item(body=final_doc)
-                                        st.success(f"Cloned {final_doc['id']}")
-                                        st.rerun()
-                                    except Exception as e:
-                                        st.error(f"Clone err: {str(e)}")
-                            col_prev, col_next = st.columns(2)
-                            with col_prev:
-                                if st.button("⬅️") and st.session_state.current_index > 0:
-                                    st.session_state.current_index -= 1
-                                    st.rerun()
-                            with col_next:
-                                if st.button("➡️") and st.session_state.current_index < total_docs - 1:
-                                    st.session_state.current_index += 1
-                                    st.rerun()
-                    elif selected_view == 'New':
-                        st.markdown("#### ➕ New Doc")
-                        if st.button("🤖 Auto-Gen"):
-                            auto_doc = {
-                                "id": generate_unique_id(),
-                                "pk": generate_unique_id(),
-                                "name": f"Auto {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
-                                "content": "Auto-generated record.",
-                                "timestamp": datetime.now().isoformat()
-                            }
-                            success, message = insert_record(container, auto_doc)
-                            if success:
-                                st.success(message)
+                        with col_next:
+                            if st.button("➡️") and st.session_state.current_index < total_docs - 1:
+                                st.session_state.current_index += 1
                                 st.rerun()
-                            else:
-                                st.error(message)
-                        else:
-                            new_id = st.text_input("ID", value=generate_unique_id(), key='new_id')
-                            default_doc = {
-                                "id": new_id,
-                                "pk": new_id,
-                                "name": "New Doc",
-                                "content": "",
-                                "timestamp": datetime.now().isoformat()
-                            }
-                            new_doc_str = st.text_area("JSON", value=json.dumps(default_doc, indent=2), height=300)
-                            if st.button("➕ Create"):
+                elif selected_view == 'Code':
+                    st.markdown("#### 💻 Code Editor")
+                    if documents:
+                        doc = documents[st.session_state.current_index]
+                        if "doc_editor" not in st.session_state:
+                            st.session_state.doc_editor = json.dumps(doc, indent=2)
+                        edited = st.text_area("Edit JSON", value=st.session_state.doc_editor, height=300, key="doc_editor", on_change=lambda: auto_save_edit())
+                        col_prev, col_next = st.columns(2)
+                        with col_prev:
+                            if st.button("⬅️") and st.session_state.current_index > 0:
+                                st.session_state.current_index -= 1
+                                st.rerun()
+                        with col_next:
+                            if st.button("➡️") and st.session_state.current_index < total_docs - 1:
+                                st.session_state.current_index += 1
+                                st.rerun()
+                        col_save, col_delete = st.columns(2)
+                        with col_save:
+                            if st.button("💾 Save", key=f'save_{st.session_state.current_index}'):
                                 try:
-                                    cleaned = preprocess_text(new_doc_str)
-                                    new_doc = json.loads(cleaned)
-                                    new_doc['id'] = new_id
-                                    new_doc['pk'] = new_id
-                                    success, message = insert_record(container, new_doc)
+                                    updated_doc = json.loads(edited)
+                                    container.upsert_item(body=updated_doc)
+                                    st.success(f"Saved {updated_doc['id']}")
+                                    st.rerun()
+                                except Exception as e:
+                                    st.error(f"Save err: {str(e)}")
+                        with col_delete:
+                            if st.button("🗑️ Delete", key=f'delete_{st.session_state.current_index}'):
+                                try:
+                                    current_doc = json.loads(edited)
+                                    success, message = delete_record(container, current_doc)
                                     if success:
-                                        st.success(f"Created {new_doc['id']}")
+                                        st.success(message)
                                         st.rerun()
                                     else:
                                         st.error(message)
                                 except Exception as e:
-                                    st.error(f"Create err: {str(e)}")
+                                    st.error(f"Delete err: {str(e)}")
+                        if "delete_log" in st.session_state and st.session_state.delete_log:
+                            st.subheader("Delete Log")
+                            for log_entry in st.session_state.delete_log[-5:]:
+                                st.write(log_entry)
+                elif selected_view == 'Run AI':
+                    st.markdown("#### 🤖 Run AI")
+                    # NEW: Use a text area and a Send button (message button UI)
+                    ai_query = st.text_area("Enter your query for ArXiv search:", key="arxiv_query", height=100)
+                    if st.button("Send"):
+                        st.session_state.last_query = ai_query
+                        perform_ai_lookup(ai_query, vocal_summary=True, extended_refs=False, titles_summary=True, full_audio=True, useArxiv=True, useArxivAudio=False)
+                elif selected_view == 'Clone':
+                    st.markdown("#### 📄 Clone")
+                    if documents:
+                        doc = documents[st.session_state.current_index]
+                        st.markdown(f"Original ID: {doc.get('id', '')}")
+                        new_id = st.text_input("New ID", value=generate_unique_id(), key='new_clone_id')
+                        new_name = st.text_input("New Name", value=f"Clone_{new_id[:8]}", key='new_clone_name')
+                        new_doc = {'id': new_id, 'pk': new_id, 'name': new_name, **{k: v for k, v in doc.items() if k not in ['id', 'name', 'pk', '_rid', '_self', '_etag', '_attachments', '_ts']}}
+                        doc_str = st.text_area("Edit JSON", value=json.dumps(new_doc, indent=2), height=300, key='clone_preview')
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            if st.button("🔄 Regenerate"):
+                                new_id = generate_unique_id()
+                                st.session_state.new_clone_id = new_id
+                                st.rerun()
+                        with col2:
+                            if st.button("💾 Save Clone"):
+                                try:
+                                    final_doc = json.loads(doc_str)
+                                    for field in ['_rid', '_self', '_etag', '_attachments', '_ts']:
+                                        final_doc.pop(field, None)
+                                    container.create_item(body=final_doc)
+                                    st.success(f"Cloned {final_doc['id']}")
+                                    st.rerun()
+                                except Exception as e:
+                                    st.error(f"Clone err: {str(e)}")
+                        col_prev, col_next = st.columns(2)
+                        with col_prev:
+                            if st.button("⬅️") and st.session_state.current_index > 0:
+                                st.session_state.current_index -= 1
+                                st.rerun()
+                        with col_next:
+                            if st.button("➡️") and st.session_state.current_index < total_docs - 1:
+                                st.session_state.current_index += 1
+                                st.rerun()
+                elif selected_view == 'New':
+                    st.markdown("#### ➕ New Doc")
+                    if st.button("🤖 Auto-Gen"):
+                        auto_doc = {
+                            "id": generate_unique_id(),
+                            "pk": generate_unique_id(),
+                            "name": f"Auto {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+                            "content": "Auto-generated record.",
+                            "timestamp": datetime.now().isoformat()
+                        }
+                        success, message = insert_record(container, auto_doc)
+                        if success:
+                            st.success(message)
+                            st.rerun()
+                        else:
+                            st.error(message)
+                    else:
+                        new_id = st.text_input("ID", value=generate_unique_id(), key='new_id')
+                        default_doc = {
+                            "id": new_id,
+                            "pk": new_id,
+                            "name": "New Doc",
+                            "content": "",
+                            "timestamp": datetime.now().isoformat()
+                        }
+                        new_doc_str = st.text_area("JSON", value=json.dumps(default_doc, indent=2), height=300)
+                        if st.button("➕ Create"):
+                            try:
+                                cleaned = preprocess_text(new_doc_str)
+                                new_doc = json.loads(cleaned)
+                                new_doc['id'] = new_id
+                                new_doc['pk'] = new_id
+                                success, message = insert_record(container, new_doc)
+                                if success:
+                                    st.success(f"Created {new_doc['id']}")
+                                    st.rerun()
+                                else:
+                                    st.error(message)
+                            except Exception as e:
+                                st.error(f"Create err: {str(e)}")
                         st.subheader(f"📊 {st.session_state.selected_container}")
                         if documents_to_display:
                             df = pd.DataFrame(documents_to_display)
                             st.dataframe(df)
                         else:
                             st.info("No docs.")
-                    
-                    # GitHub Ops section
-                    st.subheader("🐙 GitHub Ops")
-                    github_token = os.environ.get("GITHUB")
-                    source_repo = st.text_input("Source Repo URL", value="https://github.com/AaronCWacker/AIExamples-8-24-Streamlit")
-                    new_repo_name = st.text_input("New Repo Name", value=f"Clone-{datetime.now().strftime('%Y%m%d_%H%M%S')}")
-                    col_g1, col_g2 = st.columns(2)
-                    with col_g1:
-                        if st.button("📥 Clone Repo"):
-                            if github_token and source_repo:
-                                try:
-                                    local_path = f"./temp_repo_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-                                    download_github_repo(source_repo, local_path)
-                                    zip_filename = f"{new_repo_name}.zip"
-                                    create_zip_file(local_path, zip_filename[:-4])
-                                    st.markdown(get_download_link(zip_filename), unsafe_allow_html=True)
-                                    st.success("Cloned! 🎉")
-                                except Exception as e:
-                                    st.error(f"Clone err: {str(e)}")
-                                finally:
-                                    if os.path.exists(local_path):
-                                        shutil.rmtree(local_path)
-                                    if os.path.exists(zip_filename):
-                                        os.remove(zip_filename)
-                            else:
-                                st.error("Missing token or URL 🔑❓")
-                    with col_g2:
-                        if st.button("📤 Push Repo"):
-                            if github_token and source_repo:
-                                try:
-                                    g = Github(github_token)
-                                    new_repo = create_repo(g, new_repo_name)
-                                    local_path = f"./temp_repo_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-                                    download_github_repo(source_repo, local_path)
-                                    push_to_github(local_path, new_repo, github_token)
-                                    st.success(f"Pushed to {new_repo.html_url} 🚀")
-                                except Exception as e:
-                                    st.error(f"Push err: {str(e)}")
-                                finally:
-                                    if os.path.exists(local_path):
-                                        shutil.rmtree(local_path)
-                            else:
-                                st.error("Missing token or URL 🔑❓")
-                    # Display AI Samples sidebar UI (processed from Python list)
-                    display_ai_samples()
-                    update_file_management_section()
-        except exceptions.CosmosHttpResponseError as e:
-            st.error(f"Cosmos error: {str(e)} 🚨")
-        except Exception as e:
-            st.error(f"Error: {str(e)} 😱")
+                update_file_management_section()
+    except exceptions.CosmosHttpResponseError as e:
+        st.error(f"Cosmos error: {str(e)} 🚨")
+    except Exception as e:
+        st.error(f"Error: {str(e)} 😱")
     if st.session_state.logged_in and st.sidebar.button("🚪 Logout"):
         st.markdown("#### 🚪 Logout")
         st.session_state.logged_in = False
@@ -953,5 +1259,155 @@ def main():
         st.session_state.current_index = 0
         st.rerun()
 
-if __name__ == "__main__":
-    main()
+    # Also display the sidebar data grid (records overview)
+    show_sidebar_data_grid()
+
+# =============================================================================
+# Additional Blank Lines for Spacing (~1500 lines total)
+# =============================================================================
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+# End of app.py