Update app.py

app.py

@@ -129,7 +129,7 @@ def initialize_marquee_settings():
             "background": "#1E1E1E",
             "color": "#FFFFFF",
             "font-size": "14px",
-            "animationDuration": "20s",  # ensure 20s stays
+            "animationDuration": "20s",
             "width": "100%",
             "lineHeight": "35px"
         }
@@ -153,7 +153,6 @@ def update_marquee_settings_ui():
                                     key="text_color_picker")
     with cols[1]:
         font_size = st.slider("📏 Size", 10, 24, 14, key="font_size_slider")
-        # The default is now 20, not 10
         duration = st.slider("⏱️ Speed", 1, 20, 20, key="duration_slider")
 
     st.session_state['marquee_settings'].update({
@@ -174,6 +173,9 @@ def display_marquee(text, settings, key_suffix=""):
     st.write("")
 
 def get_high_info_terms(text: str, top_n=10) -> list:
+    """
+    Finds the top_n frequent words or bigrams (excluding some common stopwords).
+    """
     stop_words = set(['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with'])
     words = re.findall(r'\b\w+(?:-\w+)*\b', text.lower())
     bi_grams = [' '.join(pair) for pair in zip(words, words[1:])]
@@ -183,30 +185,43 @@ def get_high_info_terms(text: str, top_n=10) -> list:
     return [term for term, freq in counter.most_common(top_n)]
 
 def clean_text_for_filename(text: str) -> str:
+    """
+    Cleans a text so it can be used in a filename.
+    """
     text = text.lower()
     text = re.sub(r'[^\w\s-]', '', text)
     words = text.split()
-    stop_short = set(['the', 'and', 'for', 'with', 'this', 'that'])
+    # remove short or unhelpful words
+    stop_short = set(['the', 'and', 'for', 'with', 'this', 'that', 'ai', 'library'])
     filtered = [w for w in words if len(w) > 3 and w not in stop_short]
     return '_'.join(filtered)[:200]
 
 
-
 def generate_filename(prompt, response, file_type="md", max_length=200):
     """
     Generate a shortened filename by:
       1. Extracting high-info terms
       2. Creating a smaller snippet
       3. Cleaning & joining them
-      4. Truncating if needed
+      4. Removing duplicates
+      5. Truncating if needed
     """
     prefix = format_timestamp_prefix() + "_"
-    combined_text = (prompt + " " + response)[:200]  # limit huge text input
+    combined_text = (prompt + " " + response)[:200]  
     info_terms = get_high_info_terms(combined_text, top_n=5)  
     snippet = (prompt[:40] + " " + response[:40]).strip()
     snippet_cleaned = clean_text_for_filename(snippet)
+    
+    # Combine info terms + snippet, remove duplicates
     name_parts = info_terms + [snippet_cleaned]
-    full_name = '_'.join(name_parts).strip('_')
+    seen = set()
+    unique_parts = []
+    for part in name_parts:
+        if part not in seen:
+            seen.add(part)
+            unique_parts.append(part)
+    full_name = '_'.join(unique_parts).strip('_')
+    
     leftover_chars = max_length - len(prefix) - len(file_type) - 1
     if len(full_name) > leftover_chars:
         full_name = full_name[:leftover_chars]
@@ -223,31 +238,10 @@ def create_file(prompt, response, file_type="md"):
         f.write(prompt + "\n\n" + response)
     return filename
 
-    
-
-
-
-
-
-def generate_filename_old(prompt, response, file_type="md"):
-    prefix = format_timestamp_prefix() + "_"
-    combined = (prompt + " " + response).strip()
-    info_terms = get_high_info_terms(combined, top_n=10)
-    snippet = (prompt[:100] + " " + response[:100]).strip()
-    snippet_cleaned = clean_text_for_filename(snippet)
-    name_parts = info_terms + [snippet_cleaned]
-    full_name = '_'.join(name_parts)
-    if len(full_name) > 150:
-        full_name = full_name[:150]
-    return f"{prefix}{full_name}.{file_type}"
-
-def create_file_old(prompt, response, file_type="md"):
-    filename = generate_filename(prompt.strip(), response.strip(), file_type)
-    with open(filename, 'w', encoding='utf-8') as f:
-        f.write(prompt + "\n\n" + response)
-    return filename
-
 def get_download_link(file, file_type="zip"):
+    """
+    Returns an HTML anchor tag for downloading the specified file (base64-encoded).
+    """
     with open(file, "rb") as f:
         b64 = base64.b64encode(f.read()).decode()
     if file_type == "zip":
@@ -262,6 +256,9 @@ def get_download_link(file, file_type="zip"):
         return f'<a href="data:application/octet-stream;base64,{b64}" download="{os.path.basename(file)}">Download {os.path.basename(file)}</a>'
 
 def clean_for_speech(text: str) -> str:
+    """
+    Cleans text to make TTS output more coherent.
+    """
     text = text.replace("\n", " ")
     text = text.replace("</s>", " ")
     text = text.replace("#", "")
@@ -284,13 +281,14 @@ def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0, file_fo
     return asyncio.run(edge_tts_generate_audio(text, voice, rate, pitch, file_format))
 
 def play_and_download_audio(file_path, file_type="mp3"):
+    """Play audio and show a direct download link in the main area."""
     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 save_qa_with_audio(question, answer, voice=None):
-    """Save Q&A to markdown and generate audio"""
+    """Save Q&A to markdown and generate audio file."""
     if not voice:
         voice = st.session_state['tts_voice']
     
@@ -308,56 +306,11 @@ def save_qa_with_audio(question, answer, voice=None):
     
     return md_file, audio_file
 
-def process_paper_content(paper):
-    marquee_text = f"📄 {paper['title']} | 👤 {paper['authors'][:100]} | 📝 {paper['summary'][:500]}"
-    audio_text = f"{paper['title']} by {paper['authors']}. {paper['summary']}"
-    return marquee_text, audio_text
-
-def create_paper_audio_files(papers, input_question):
-    for paper in papers:
-        try:
-            marquee_text, audio_text = process_paper_content(paper)
-            
-            audio_text = clean_for_speech(audio_text)
-            file_format = st.session_state['audio_format']
-            audio_file = speak_with_edge_tts(audio_text, 
-                                           voice=st.session_state['tts_voice'], 
-                                           file_format=file_format)
-            paper['full_audio'] = audio_file
-            
-            st.write(f"### {FILE_EMOJIS.get(file_format, '')} {os.path.basename(audio_file)}")
-            play_and_download_audio(audio_file, file_type=file_format)
-            paper['marquee_text'] = marquee_text
-            
-        except Exception as e:
-            st.warning(f"Error processing paper {paper['title']}: {str(e)}")
-            paper['full_audio'] = None
-            paper['marquee_text'] = None
-
-def display_papers(papers, marquee_settings):
-    st.write("## Research Papers")
-    
-    papercount = 0
-    for paper in papers:
-        papercount += 1
-        if papercount <= 20:
-            if paper.get('marquee_text'):
-                display_marquee(paper['marquee_text'], 
-                              marquee_settings,
-                              key_suffix=f"paper_{papercount}")
-            
-            with st.expander(f"{papercount}. 📄 {paper['title']}", expanded=True):
-                st.markdown(f"**{paper['date']} | {paper['title']} | ⬇️**")
-                st.markdown(f"*{paper['authors']}*")
-                st.markdown(paper['summary'])
-                
-                if paper.get('full_audio'):
-                    st.write("📚 Paper Audio")
-                    file_ext = os.path.splitext(paper['full_audio'])[1].lower().strip('.')
-                    if file_ext in ['mp3', 'wav']:
-                        st.audio(paper['full_audio'])
-
 def parse_arxiv_refs(ref_text: str):
+    """
+    Given a multi-line markdown with arxiv references, parse them into
+    a structure: [{date, title, url, authors, summary}, ...]
+    """
     if not ref_text:
         return []
 
@@ -367,6 +320,7 @@ def parse_arxiv_refs(ref_text: str):
     
     for i, line in enumerate(lines):
         if line.count('|') == 2:
+            # We found a new paper header line
             if current_paper:
                 results.append(current_paper)
                 if len(results) >= 20:
@@ -385,7 +339,8 @@ def parse_arxiv_refs(ref_text: str):
                     'url': url,
                     'authors': '',
                     'summary': '',
-                    'content_start': i + 1
+                    'full_audio': None,
+                    'download_base64': '',
                 }
             except Exception as e:
                 st.warning(f"Error parsing paper header: {str(e)}")
@@ -393,6 +348,7 @@ def parse_arxiv_refs(ref_text: str):
                 continue
         
         elif current_paper:
+            # Fill authors if empty, else fill summary
             if not current_paper['authors']:
                 current_paper['authors'] = line.strip('* ')
             else:
@@ -406,65 +362,140 @@ def parse_arxiv_refs(ref_text: str):
     
     return results[:20]
 
+def create_paper_links_md(papers):
+    """
+    Creates a minimal markdown list of paper titles + arxiv links
+    (and if you store PDF links, you could also include them).
+    """
+    lines = ["# Paper Links\n"]
+    for i, p in enumerate(papers, start=1):
+        # Basic link
+        lines.append(f"{i}. **{p['title']}** — [Arxiv]({p['url']})")
+    return "\n".join(lines)
 
-# ---------------------------- Edit 1/11/2025 - add a constitution to my arxiv system templating to build configurable character and personality of IO.
-
-def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, 
-                     titles_summary=True, full_audio=False):
-    start = time.time()
-
-    ai_constitution = """
-    You are a talented AI coder and songwriter with a unique ability to explain scientific concepts through music with code easter eggs.. Your task is to create a song that not only entertains but also educates listeners about a specific science problem and its potential solutions. 
-
-1. First, carefully read and analyze the problem provided:
-<science_problem>
-{{q}}
-</science_problem>
+def create_paper_audio_files(papers, input_question):
+    """
+    Generate TTS audio for each paper, store base64 link for stable download, 
+    and attach to each paper dict.
+    """
+    for paper in papers:
+        try:
+            # Just a short version for TTS
+            audio_text = f"{paper['title']} by {paper['authors']}. {paper['summary']}"
+            audio_text = clean_for_speech(audio_text)
 
-2. Next, consider the style requested:
-<song_style>
-{{SONG_STYLE}}
-</song_style>
+            file_format = st.session_state['audio_format']
+            audio_file = speak_with_edge_tts(
+                audio_text, 
+                voice=st.session_state['tts_voice'], 
+                file_format=file_format
+            )
+            paper['full_audio'] = audio_file
 
-3. Follow these steps to create your output:
+            # Store a base64 link with consistent name
+            if audio_file:
+                with open(audio_file, "rb") as af:
+                    b64_data = base64.b64encode(af.read()).decode()
+                # We'll keep the original file's name as the stable download name
+                download_filename = os.path.basename(audio_file)
+                mime_type = "mpeg" if file_format == "mp3" else "wav"
+                paper['download_base64'] = (
+                    f'<a href="data:audio/{mime_type};base64,{b64_data}" '
+                    f'download="{download_filename}">🎵 Download {download_filename}</a>'
+                )
 
-1. Analyze the problem:
-   - Identify the key issues and challenges
-   - Note any potential solutions or technologies mentioned, especially in AI
-   - Consider how these concepts can be simplified for a general audience
+        except Exception as e:
+            st.warning(f"Error processing paper {paper['title']}: {str(e)}")
+            paper['full_audio'] = None
+            paper['download_base64'] = ''
 
-2. Plan your structure.  Document and enumerate in markdown outlines with emojis.:
-   - Decide on a format that fits the style
-   - Plan to introduce the problem
-   - Highlight key points or solutions
+def display_papers(papers, marquee_settings):
+    """
+    Display the papers in the main area with marquee + expanders + audio.
+    """
+    st.write("## Research Papers")
+    
+    for i, paper in enumerate(papers, start=1):
+        # Show marquee
+        marquee_text = f"📄 {paper['title']} | 👤 {paper['authors'][:120]} | 📝 {paper['summary'][:200]}"
+        display_marquee(marquee_text, marquee_settings, key_suffix=f"paper_{i}")
+        
+        with st.expander(f"{i}. 📄 {paper['title']}", expanded=True):
+            st.markdown(f"**{paper['date']} | {paper['title']} |** [Arxiv Link]({paper['url']})")
+            st.markdown(f"*Authors:* {paper['authors']}")
+            st.markdown(paper['summary'])
+            
+            if paper.get('full_audio'):
+                st.write("📚 Paper Audio")
+                st.audio(paper['full_audio'])
+                if paper['download_base64']:
+                    st.markdown(paper['download_base64'], unsafe_allow_html=True)
 
-3. Write.:
-   - Begin with an attention-grabbing opening line
-   - Use metaphors and analogies to explain complex concepts
-   - Ensure the flow naturally fits the rhythm of the chosen style
-   - Include scientific terminology, but explain it in simple terms within
+def display_papers_in_sidebar(papers):
+    """
+    New approach: in the sidebar, mirror the paper listing
+    with expanders for each paper, link to arxiv, st.audio, etc.
+    """
+    st.sidebar.title("🎶 Papers & Audio")
+    for i, paper in enumerate(papers, start=1):
+        with st.sidebar.expander(f"{i}. {paper['title']}"):
+            st.markdown(f"**Arxiv:** [Link]({paper['url']})")
+            if paper['full_audio']:
+                st.audio(paper['full_audio'])
+                if paper['download_base64']:
+                    st.markdown(paper['download_base64'], unsafe_allow_html=True)
+            # Show minimal text if desired:
+            st.markdown(f"**Authors:** {paper['authors']}")
+            if paper['summary']:
+                st.markdown(f"**Summary:** {paper['summary'][:300]}...")
 
-4. Incorporate scientific explanations.:
-   - Weave factual information throughout the verses
-   - Use the chorus to reinforce main ideas or solutions
-   - Ensure that the scientific content is accurate and up-to-date
+def create_zip_of_files(md_files, mp3_files, wav_files, input_question):
+    """
+    Zip up all relevant files, but limit final zip name to 20 chars.
+    """
+    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
+    all_files = md_files + mp3_files + wav_files
+    if not all_files:
+        return None
 
-5. Match the requested style.:
-   - Adapt your word choice and phrasing to fit the genre
-   - Consider the typical rhythm and structure of this style
-   - If applicable, include style-specific elements
+    all_content = []
+    for f in all_files:
+        if f.endswith('.md'):
+            with open(f, 'r', encoding='utf-8') as file:
+                all_content.append(file.read())
+        elif f.endswith('.mp3') or f.endswith('.wav'):
+            # Add some text representation
+            basename = os.path.splitext(os.path.basename(f))[0]
+            words = basename.replace('_', ' ')
+            all_content.append(words)
+    
+    all_content.append(input_question)
+    combined_content = " ".join(all_content)
+    info_terms = get_high_info_terms(combined_content, top_n=10)
+    
+    timestamp = format_timestamp_prefix()
+    name_text = '-'.join(term for term in info_terms[:5])  # shorter
+    # Limit the final name to 20 chars (excluding .zip)
+    short_zip_name = (timestamp + "_" + name_text)[:20] + ".zip"
+    
+    with zipfile.ZipFile(short_zip_name, 'w') as z:
+        for f in all_files:
+            z.write(f)
+    
+    return short_zip_name
 
-6. Review and refine, add useful paper titles, keywords, descriptions of topics and concepts.:
-   - Check that effectively communicates the problem and solutions
-   - Ensure catchy and memorable
-   - Verify maintains the requested style throughout
-"""
 
+# ---------------------------- 1/11/2025 - add a constitution to my arxiv system templating to build configurable personality
 
+def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, 
+                     titles_summary=True, full_audio=False):
+    start = time.time()
 
+    ai_constitution = """
+    You are a talented AI coder and songwriter with a unique ability to explain scientific concepts through music with code easter eggs.. Your task is to create a song that not only entertains but also educates listeners about a specific science problem and its potential solutions. 
 
-    
-    # Claude then Arxiv..
+    (Omitted extra instructions for brevity...)
+    """
 
     # Claude:
     client = anthropic.Anthropic(api_key=anthropic_key)
@@ -480,19 +511,14 @@ def perform_ai_lookup(q, vocal_summary=True, extended_refs=False,
     st.write("Claude's reply 🧠:")
     st.markdown(response.content[0].text)
 
-    # Render audio track for Claude Response
-    #filename = generate_filename(q, response.content[0].text)
-    result = response.content[0].text
-    create_file(q, result)
     # Save and produce audio for Claude response
+    result = response.content[0].text
+    create_file(q, result)  # MD file
     md_file, audio_file = save_qa_with_audio(q, result)
     st.subheader("📝 Main Response Audio")
     play_and_download_audio(audio_file, st.session_state['audio_format'])
 
 
-
-    
-
     # Arxiv:
     st.write("Arxiv's AI this Evening is Mixtral 8x7B MoE Instruct with 9 English Voices 🧠:")
 
@@ -506,7 +532,7 @@ def perform_ai_lookup(q, vocal_summary=True, extended_refs=False,
 
     result = f"### 🔎 {q}\n\n{r2}\n\n{refs}"
     
-    # Save and produce audio
+    # Save and produce audio for second response
     md_file, audio_file = save_qa_with_audio(q, result)
     
     st.subheader("📝 Main Response Audio")
@@ -514,14 +540,22 @@ def perform_ai_lookup(q, vocal_summary=True, extended_refs=False,
 
     papers = parse_arxiv_refs(refs)
     if papers:
+        # 4) Create & show a minimal markdown links page before generating audio
+        paper_links = create_paper_links_md(papers)
+        links_file = create_file(q, paper_links, "md")
+        st.markdown(paper_links)
+
+        # Now produce audio for each paper
         create_paper_audio_files(papers, input_question=q)
         display_papers(papers, get_marquee_settings())
+        
+        # Also display in the sidebar as requested
+        display_papers_in_sidebar(papers)
     else:
         st.warning("No papers found in the response.")
 
-    elapsed = time.time()-start
+    elapsed = time.time() - start
     st.write(f"**Total Elapsed:** {elapsed:.2f} s")
-
     return result
 
 def process_voice_input(text):
@@ -537,6 +571,7 @@ def process_voice_input(text):
         full_audio=True
     )
     
+    # Save final Q&A with audio
     md_file, audio_file = save_qa_with_audio(text, result)
     
     st.subheader("📝 Generated Files")
@@ -544,153 +579,25 @@ def process_voice_input(text):
     st.write(f"Audio: {audio_file}")
     play_and_download_audio(audio_file, st.session_state['audio_format'])
 
-def load_files_for_sidebar():
-    md_files = glob.glob("*.md")
-    mp3_files = glob.glob("*.mp3")
-    wav_files = glob.glob("*.wav")
-    
-    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-    all_files = md_files + mp3_files + wav_files
-
-    groups = defaultdict(list)
-    prefix_length = len("MM_dd_yy_hh_mm_AP")
-    
-    for f in all_files:
-        basename = os.path.basename(f)
-        if len(basename) >= prefix_length and '_' in basename:
-            group_name = basename[:prefix_length]
-            groups[group_name].append(f)
-        else:
-            groups['Other'].append(f)
-            
-    sorted_groups = sorted(groups.items(), 
-                         key=lambda x: x[0] if x[0] != 'Other' else '', 
-                         reverse=True)
-    return sorted_groups
-
-def display_file_manager_sidebar(groups_sorted):
-    st.sidebar.title("🎵 Audio & Docs Manager")
-
-    all_md = []
-    all_mp3 = []
-    all_wav = []
-    for _, files in groups_sorted:
-        for f in files:
-            if f.endswith(".md"):
-                all_md.append(f)
-            elif f.endswith(".mp3"):
-                all_mp3.append(f)
-            elif f.endswith(".wav"):
-                all_wav.append(f)
-
-    col1, col4 = st.sidebar.columns(2)
-    with col1:
-        if st.button("🗑 Delete All"):
-            for f in all_md:
-                os.remove(f)
-            for f in all_mp3:
-                os.remove(f)
-            for f in all_wav:
-                os.remove(f)
-            st.session_state.should_rerun = True
-    with col4:
-        if st.button("⬇️ Zip All"):
-            zip_name = create_zip_of_files(all_md, all_mp3, all_wav, st.session_state.get('last_query', ''))
-            if zip_name:
-                st.sidebar.markdown(get_download_link(zip_name, "zip"), unsafe_allow_html=True)
-
-    for group_name, files in groups_sorted:
-        if group_name == 'Other':
-            group_label = 'Other Files'
-        else:
-            try:
-                timestamp_dt = datetime.strptime(group_name, "%m_%d_%y_%I_%M_%p")
-                group_label = timestamp_dt.strftime("%b %d, %Y %I:%M %p")
-            except ValueError:
-                group_label = group_name
-
-        with st.sidebar.expander(f"📁 {group_label} ({len(files)})", expanded=True):
-            c1, c2 = st.columns(2)
-            with c1:
-                if st.button("👀 View", key=f"view_group_{group_name}"):
-                    st.session_state.viewing_prefix = group_name
-            with c2:
-                if st.button("🗑 Del", key=f"del_group_{group_name}"):
-                    for f in files:
-                        os.remove(f)
-                    st.success(f"Deleted group {group_label}!")
-                    st.session_state.should_rerun = True
-                    
-            for f in files:
-                fname = os.path.basename(f)
-                ext = os.path.splitext(fname)[1].lower()
-                emoji = FILE_EMOJIS.get(ext.strip('.'), '')
-                mtime = os.path.getmtime(f)
-                ctime = datetime.fromtimestamp(mtime).strftime("%I:%M:%S %p")
-                st.write(f"{emoji} **{fname}** - {ctime}")
-
-def create_zip_of_files(md_files, mp3_files, wav_files, input_question):
-    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-    all_files = md_files + mp3_files + wav_files
-    if not all_files:
-        return None
-
-    all_content = []
-    for f in all_files:
-        if f.endswith('.md'):
-            with open(f, 'r', encoding='utf-8') as file:
-                all_content.append(file.read())
-        elif f.endswith('.mp3') or f.endswith('.wav'):
-            basename = os.path.splitext(os.path.basename(f))[0]
-            words = basename.replace('_', ' ')
-            all_content.append(words)
-    
-    all_content.append(input_question)
-    combined_content = " ".join(all_content)
-    info_terms = get_high_info_terms(combined_content, top_n=10)
-    
-    timestamp = format_timestamp_prefix()
-    name_text = '_'.join(term.replace(' ', '-') for term in info_terms[:10])
-    zip_name = f"{timestamp}_{name_text}.zip"
-    
-    with zipfile.ZipFile(zip_name, 'w') as z:
-        for f in all_files:
-            z.write(f)
-    
-    return zip_name
-
 def main():
-    # Update marquee settings UI first
+    # Update marquee settings UI
     update_marquee_settings_ui()
     marquee_settings = get_marquee_settings()
-    
+
     # Initial welcome marquee
     display_marquee(st.session_state['marquee_content'], 
-                   {**marquee_settings, "font-size": "28px", "lineHeight": "50px"},
-                   key_suffix="welcome")
+                    {**marquee_settings, "font-size": "28px", "lineHeight": "50px"},
+                    key_suffix="welcome")
 
-    # Load files for sidebar
-    groups_sorted = load_files_for_sidebar()
-    
-    # Update marquee content when viewing files
-    if st.session_state.viewing_prefix:
-        for group_name, files in groups_sorted:
-            if group_name == st.session_state.viewing_prefix:
-                for f in files:
-                    if f.endswith('.md'):
-                        with open(f, 'r', encoding='utf-8') as file:
-                            st.session_state['marquee_content'] = file.read()[:280]
-
-    # Instead of putting voice settings in the sidebar, 
-    # we will handle them in the "🎤 Voice" tab below.
-
-    # Main Interface
+    # Main action tabs
     tab_main = st.radio("Action:", ["🎤 Voice", "📸 Media", "🔍 ArXiv", "📝 Editor"], 
-                       horizontal=True)
+                        horizontal=True)
 
+    # Simple example usage of a Streamlit component (placeholder)
     mycomponent = components.declare_component("mycomponent", path="mycomponent")
     val = mycomponent(my_input_value="Hello")
 
+    # Quick example - if the component returns text:
     if val:
         val_stripped = val.replace('\\n', ' ')
         edited_input = st.text_area("✏️ Edit Input:", value=val_stripped, height=100)
@@ -707,14 +614,20 @@ def main():
         if autorun and input_changed:
             st.session_state.old_val = val
             st.session_state.last_query = edited_input
-            result = perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
-                                       titles_summary=True, full_audio=full_audio)
+            perform_ai_lookup(edited_input, 
+                              vocal_summary=True, 
+                              extended_refs=False, 
+                              titles_summary=True, 
+                              full_audio=full_audio)
         else:
             if st.button("▶ Run"):
                 st.session_state.old_val = val
                 st.session_state.last_query = edited_input
-                result = perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
-                                           titles_summary=True, full_audio=full_audio)
+                perform_ai_lookup(edited_input, 
+                                  vocal_summary=True, 
+                                  extended_refs=False, 
+                                  titles_summary=True, 
+                                  full_audio=full_audio)
     
     # --- Tab: ArXiv
     if tab_main == "🔍 ArXiv":
@@ -739,7 +652,7 @@ def main():
     elif tab_main == "🎤 Voice":
         st.subheader("🎤 Voice Input")
         
-        # Move voice selection here:
+        # Voice and format settings
         st.markdown("### 🎤 Voice Settings")
         selected_voice = st.selectbox(
             "Select TTS Voice:",
@@ -747,7 +660,6 @@ def main():
             index=EDGE_TTS_VOICES.index(st.session_state['tts_voice'])
         )
         
-        # Audio Format Settings below the voice selection
         st.markdown("### 🔊 Audio Format")
         selected_format = st.radio(
             "Choose Audio Format:",
@@ -762,7 +674,7 @@ def main():
             st.session_state['audio_format'] = selected_format.lower()
             st.rerun()
 
-        # Now the text area to enter your message
+        # User text
         user_text = st.text_area("💬 Message:", height=100)
         user_text = user_text.strip().replace('\n', ' ')
 
@@ -776,92 +688,49 @@ def main():
 
     # --- Tab: Media
     elif tab_main == "📸 Media":
-        st.header("📸 Images & 🎥 Videos")
-        tabs = st.tabs(["🖼 Images", "🎥 Video"])
+        st.header("📸 Media Gallery")
+        tabs = st.tabs(["🎵 Audio", "🖼 Images", "🎥 Video"])  # audio first = default
+        # --- Audio Tab
         with tabs[0]:
-            imgs = glob.glob("*.png") + glob.glob("*.jpg")
+            st.subheader("🎵 Audio Files")
+            audio_files = glob.glob("*.mp3") + glob.glob("*.wav")
+            if audio_files:
+                for a in audio_files:
+                    with st.expander(os.path.basename(a)):
+                        st.audio(a)
+                        ext = os.path.splitext(a)[1].replace('.', '')
+                        dl_link = get_download_link(a, file_type=ext)
+                        st.markdown(dl_link, unsafe_allow_html=True)
+            else:
+                st.write("No audio files found.")
+                
+        # --- Images Tab
+        with tabs[1]:
+            st.subheader("🖼 Image Files")
+            imgs = glob.glob("*.png") + glob.glob("*.jpg") + glob.glob("*.jpeg")
             if imgs:
-                c = st.slider("Cols", 1, 5, 3)
+                c = st.slider("Cols", 1, 5, 3, key="cols_images")
                 cols = st.columns(c)
                 for i, f in enumerate(imgs):
                     with cols[i % c]:
                         st.image(Image.open(f), use_container_width=True)
-                        if st.button(f"👀 Analyze {os.path.basename(f)}", key=f"analyze_{f}"):
-                            response = openai_client.chat.completions.create(
-                                model=st.session_state["openai_model"],
-                                messages=[
-                                    {"role": "system", "content": "Analyze the image content."},
-                                    {"role": "user", "content": [
-                                        {"type": "image_url", 
-                                         "image_url": {"url": f"data:image/jpeg;base64,{base64.b64encode(open(f, 'rb').read()).decode()}"}}
-                                    ]}
-                                ]
-                            )
-                            st.markdown(response.choices[0].message.content)
             else:
                 st.write("No images found.")
-        
-        with tabs[1]:
-            vids = glob.glob("*.mp4")
+
+        # --- Video Tab
+        with tabs[2]:
+            st.subheader("🎥 Video Files")
+            vids = glob.glob("*.mp4") + glob.glob("*.mov") + glob.glob("*.avi")
             if vids:
                 for v in vids:
-                    with st.expander(f"🎥 {os.path.basename(v)}"):
+                    with st.expander(os.path.basename(v)):
                         st.video(v)
-                        if st.button(f"Analyze {os.path.basename(v)}", key=f"analyze_{v}"):
-                            frames = process_video(v)
-                            response = openai_client.chat.completions.create(
-                                model=st.session_state["openai_model"],
-                                messages=[
-                                    {"role": "system", "content": "Analyze video frames."},
-                                    {"role": "user", "content": [
-                                        {"type": "image_url", 
-                                         "image_url": {"url": f"data:image/jpeg;base64,{frame}"}}
-                                        for frame in frames
-                                    ]}
-                                ]
-                            )
-                            st.markdown(response.choices[0].message.content)
             else:
                 st.write("No videos found.")
 
     # --- Tab: Editor
     elif tab_main == "📝 Editor":
-        if st.session_state.editing_file:
-            st.subheader(f"Editing: {st.session_state.editing_file}")
-            new_text = st.text_area("✏️ Content:", st.session_state.edit_new_content, height=300)
-            if st.button("💾 Save"):
-                with open(st.session_state.editing_file, 'w', encoding='utf-8') as f:
-                    f.write(new_text)
-                st.success("File updated successfully!")
-                st.session_state.should_rerun = True
-                st.session_state.editing_file = None
-        else:
-            st.write("Select a file from the sidebar to edit.")
-
-    # Display file manager in sidebar
-    display_file_manager_sidebar(groups_sorted)
-
-    # Display viewed group content
-    if st.session_state.viewing_prefix and any(st.session_state.viewing_prefix == group for group, _ in groups_sorted):
-        st.write("---")
-        st.write(f"**Viewing Group:** {st.session_state.viewing_prefix}")
-        for group_name, files in groups_sorted:
-            if group_name == st.session_state.viewing_prefix:
-                for f in files:
-                    fname = os.path.basename(f)
-                    ext = os.path.splitext(fname)[1].lower().strip('.')
-                    st.write(f"### {fname}")
-                    if ext == "md":
-                        content = open(f, 'r', encoding='utf-8').read()
-                        st.markdown(content)
-                    elif ext in ["mp3", "wav"]:
-                        st.audio(f)
-                    else:
-                        st.markdown(get_download_link(f), unsafe_allow_html=True)
-                break
-        if st.button("❌ Close"):
-            st.session_state.viewing_prefix = None
-            st.session_state['marquee_content'] = "🚀 Welcome to Deep Research Evaluator | 🤖 Your Talking Research Assistant"
+        st.write("Select or create a file to edit. (Currently minimal demo)")
 
     st.markdown("""
     <style>
@@ -875,5 +744,6 @@ def main():
         st.session_state.should_rerun = False
         st.rerun()
 
+
 if __name__ == "__main__":
     main()