Update app.py

app.py

@@ -5,7 +5,7 @@ import streamlit.components.v1 as components
 from datetime import datetime
 from audio_recorder_streamlit import audio_recorder
 from bs4 import BeautifulSoup
-from collections import defaultdict, deque
+from collections import defaultdict
 from dotenv import load_dotenv
 from gradio_client import Client
 from huggingface_hub import InferenceClient
@@ -20,128 +20,54 @@ from streamlit.runtime.scriptrunner import get_script_run_ctx
 import asyncio
 import edge_tts
 
-# 🎯 1. Core Configuration & Setup
+# --- Configuration & Setup ---
 st.set_page_config(
-    page_title="🚲BikeAI🏆 Claude/GPT Research",
+    page_title="BikeAI Claude/GPT Research",
     page_icon="🚲🏆",
     layout="wide",
     initial_sidebar_state="auto",
     menu_items={
         'Get Help': 'https://huggingface.co/awacke1',
         'Report a bug': 'https://huggingface.co/spaces/awacke1',
-        'About': "🚲BikeAI🏆 Claude/GPT Research AI"
+        'About': "BikeAI Claude/GPT Research AI"
     }
 )
 load_dotenv()
 
-# 🧠 2. Text Cleaning Functionality
-class TextCleaner:
-    """Helper class for text cleaning operations"""
-    def __init__(self):
-        self.replacements = {
-            "\\n": " ",     # Replace escaped newlines
-            "</s>": "",     # Remove end tags
-            "<s>": "",      # Remove start tags
-            "\n": " ",      # Replace actual newlines
-            "\r": " ",      # Replace carriage returns
-            "\t": " ",      # Replace tabs
-        }
-        
-        self.preserve_replacements = {
-            "\\n": "\n",    # Convert escaped to actual newlines
-            "</s>": "",     # Remove end tags
-            "<s>": "",      # Remove start tags
-            "\r": "\n",     # Convert returns to newlines
-            "\t": "    "    # Convert tabs to spaces
-        }
-
-    def clean_text(self, text: str, preserve_format: bool = False) -> str:
-        """
-        Clean text removing problematic characters and normalizing whitespace.
-        Args:
-            text: Text to clean
-            preserve_format: Whether to preserve some formatting (newlines etc)
-        Returns:
-            Cleaned text string
-        """
-        if not text or not isinstance(text, str):
-            return ""
-            
-        replacements = (self.preserve_replacements if preserve_format 
-                       else self.replacements)
-        
-        cleaned = text
-        for old, new in replacements.items():
-            cleaned = cleaned.replace(old, new)
-            
-        # Normalize whitespace while preserving paragraphs if needed
-        if preserve_format:
-            cleaned = re.sub(r'\n{3,}', '\n\n', cleaned)
-        else:
-            cleaned = re.sub(r'\s+', ' ', cleaned)
-            
-        return cleaned.strip()
-
-    def clean_dict(self, data: dict, fields: list) -> dict:
-        """Clean specified fields in a dictionary"""
-        if not data or not isinstance(data, dict):
-            return {}
-            
-        cleaned = data.copy()
-        for field in fields:
-            if field in cleaned:
-                cleaned[field] = self.clean_text(cleaned[field])
-        return cleaned
-
-    def clean_list(self, items: list, fields: list) -> list:
-        """Clean specified fields in a list of dictionaries"""
-        if not isinstance(items, list):
-            return []
-        return [self.clean_dict(item, fields) for item in items]
-
-# Initialize cleaner
-cleaner = TextCleaner()
-
-# 🔑 3. API Setup & Clients
-openai_api_key = os.getenv('OPENAI_API_KEY', "")
-anthropic_key = os.getenv('ANTHROPIC_API_KEY_3', "")
-xai_key = os.getenv('xai',"")
-if 'OPENAI_API_KEY' in st.secrets:
-    openai_api_key = st.secrets['OPENAI_API_KEY']
-if 'ANTHROPIC_API_KEY' in st.secrets:
-    anthropic_key = st.secrets["ANTHROPIC_API_KEY"]
+# --- API Setup & Clients ---
+def init_api_clients():
+    api_keys = {k: os.getenv(k, "") for k in ('OPENAI_API_KEY', 'ANTHROPIC_API_KEY_3', 'xai', 'HF_KEY', 'API_URL')}
+    api_keys.update({k: v for k, v in st.secrets.items() if k in api_keys})
+    openai.api_key = api_keys['OPENAI_API_KEY']
+    return {
+        'claude': anthropic.Anthropic(api_key=api_keys['ANTHROPIC_API_KEY_3']),
+        'openai': OpenAI(api_key=openai.api_key)
+    }
 
-openai.api_key = openai_api_key
-claude_client = anthropic.Anthropic(api_key=anthropic_key)
-openai_client = OpenAI(api_key=openai.api_key, organization=os.getenv('OPENAI_ORG_ID'))
-HF_KEY = os.getenv('HF_KEY')
-API_URL = os.getenv('API_URL')
+api_clients = init_api_clients()
+
+# --- Session State Management ---
+def initialize_session_state():
+    defaults = {
+        'transcript_history': [],
+        'chat_history': [],
+        'openai_model': "gpt-4o-2024-05-13",
+        'messages': [],
+        'last_voice_input': "",
+        'editing_file': None,
+        'edit_new_name': "",
+        'edit_new_content': "",
+        'viewing_prefix': None,
+        'should_rerun': False,
+        'old_val': None
+    }
+    for k, v in defaults.items():
+        if k not in st.session_state:
+            st.session_state[k] = v
 
-# 📝 4. Session State Management 
-if 'transcript_history' not in st.session_state:
-    st.session_state['transcript_history'] = []
-if 'chat_history' not in st.session_state:
-    st.session_state['chat_history'] = []
-if 'openai_model' not in st.session_state:
-    st.session_state['openai_model'] = "gpt-4-1106-preview"
-if 'messages' not in st.session_state:
-    st.session_state['messages'] = []
-if 'last_voice_input' not in st.session_state:
-    st.session_state['last_voice_input'] = ""
-if 'editing_file' not in st.session_state:
-    st.session_state['editing_file'] = None
-if 'edit_new_name' not in st.session_state:
-    st.session_state['edit_new_name'] = ""
-if 'edit_new_content' not in st.session_state:
-    st.session_state['edit_new_content'] = ""
-if 'viewing_prefix' not in st.session_state:  
-    st.session_state['viewing_prefix'] = None
-if 'should_rerun' not in st.session_state:
-    st.session_state['should_rerun'] = False
-if 'old_val' not in st.session_state:
-    st.session_state['old_val'] = None
+initialize_session_state()
 
-# 🎨 5. Custom CSS
+# --- Custom CSS ---
 st.markdown("""
 <style>
     .main { background: linear-gradient(to right, #1a1a1a, #2d2d2d); color: #fff; }
@@ -150,565 +76,69 @@ st.markdown("""
 </style>
 """, unsafe_allow_html=True)
 
-FILE_EMOJIS = {
-    "md": "📝",
-    "mp3": "🎵",
-}
-
-# 🧠 6. High-Information Content Extraction
+# --- Helper Functions ---
 def get_high_info_terms(text: str) -> list:
-    """Extract high-information terms from text, including key phrases."""
-    text = cleaner.clean_text(text)
-    
-    # ... rest of function remains the same ...
-    [Your existing get_high_info_terms implementation]
+    stop_words = set(['the', 'a', 'an', 'and', 'or', 'in', 'on', 'at', 'to', 'for', 'with'])
+    key_phrases = ['artificial intelligence', 'machine learning', 'neural network']
+    preserved = [p for p in key_phrases if p in text.lower()]
+    words = re.findall(r'\b\w+(?:-\w+)*\b', text.lower())
+    high_info_words = [w for w in words if w not in stop_words and len(w) > 3]
+    return list(dict.fromkeys(preserved + high_info_words))[:5]
 
-def clean_text_for_filename(text: str) -> str:
-    """Remove punctuation and short filler words, return a compact string."""
-    text = cleaner.clean_text(text)
-    
-    # ... rest of function remains the same ...
-    [Your existing clean_text_for_filename implementation]
 
-# 📁 7. File Operations
 def generate_filename(prompt, response, file_type="md"):
-    """Generate filename with meaningful terms."""
-    cleaned_prompt = cleaner.clean_text(prompt)
-    cleaned_response = cleaner.clean_text(response)
-    
-    prefix = datetime.now().strftime("%y%m_%H%M") + "_"
-    combined = (cleaned_prompt + " " + cleaned_response).strip()
-    info_terms = get_high_info_terms(combined)
-    
-    snippet = (cleaned_prompt[:100] + " " + cleaned_response[:100]).strip()
-    snippet_cleaned = clean_text_for_filename(snippet)
-    
-    name_parts = info_terms + [snippet_cleaned]
-    full_name = '_'.join(name_parts)
+    prefix = datetime.now().strftime("%y%m_%H%M")
+    info_terms = get_high_info_terms(prompt + response)
+    snippet = '_'.join(info_terms)
+    return f"{prefix}_{snippet[:150]}.{file_type}"
 
-    if len(full_name) > 150:
-        full_name = full_name[:150]
-    
-    filename = f"{prefix}{full_name}.{file_type}"
-    return filename
 
 def create_file(prompt, response, file_type="md"):
-    """Create file with intelligent naming"""
-    filename = generate_filename(prompt.strip(), response.strip(), file_type)
-    
-    cleaned_prompt = cleaner.clean_text(prompt)
-    cleaned_response = cleaner.clean_text(response, preserve_format=True)
-    
+    filename = generate_filename(prompt, response, file_type)
     with open(filename, 'w', encoding='utf-8') as f:
-        f.write(cleaned_prompt + "\n\n" + cleaned_response)
+        f.write(f"{prompt}\n\n{response}")
     return filename
 
-def get_download_link(file):
-    """Generate download link for file"""
-    with open(file, "rb") as f:
-        b64 = base64.b64encode(f.read()).decode()
-    return f'<a href="data:file/zip;base64,{b64}" download="{os.path.basename(file)}">📂 Download {os.path.basename(file)}</a>'
-
-# 🔊 8. Audio Processing
-def clean_for_speech(text: str) -> str:
-    """Clean text for speech synthesis"""
-    text = cleaner.clean_text(text)
-    text = re.sub(r"\(https?:\/\/[^\)]+\)", "", text)
-    return text
-
-@st.cache_resource
-def speech_synthesis_html(result):
-    """Create HTML for speech synthesis"""
-    cleaned_result = clean_for_speech(result)
-    html_code = f"""
-    <html><body>
-    <script>
-    var msg = new SpeechSynthesisUtterance("{cleaned_result.replace('"', '')}");
-    window.speechSynthesis.speak(msg);
-    </script>
-    </body></html>
-    """
-    components.html(html_code, height=0)
-
-async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=0):
-    """Generate audio using Edge TTS"""
-    text = clean_for_speech(text)
-    if not text.strip():
-        return None
-    rate_str = f"{rate:+d}%"
-    pitch_str = f"{pitch:+d}Hz"
-    communicate = edge_tts.Communicate(text, voice, rate=rate_str, pitch=pitch_str)
-    out_fn = generate_filename(text, text, "mp3")
-    await communicate.save(out_fn)
-    return out_fn
-
-def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0):
-    """Wrapper for edge TTS generation"""
-    return asyncio.run(edge_tts_generate_audio(text, voice, rate, pitch))
 
 def play_and_download_audio(file_path):
-    """Play and provide download link for audio"""
     if file_path and os.path.exists(file_path):
         st.audio(file_path)
-        dl_link = f'<a href="data:audio/mpeg;base64,{base64.b64encode(open(file_path,"rb").read()).decode()}" download="{os.path.basename(file_path)}">Download {os.path.basename(file_path)}</a>'
-        st.markdown(dl_link, unsafe_allow_html=True)
-
-# 🎬 9. Media Processing
-def process_image(image_path, user_prompt):
-    """Process image with GPT-4V"""
-    with open(image_path, "rb") as imgf:
-        image_data = imgf.read()
-    b64img = base64.b64encode(image_data).decode("utf-8")
-    
-    cleaned_prompt = cleaner.clean_text(user_prompt)
-    
-    resp = openai_client.chat.completions.create(
-        model=st.session_state["openai_model"],
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": [
-                {"type": "text", "text": cleaned_prompt},
-                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64img}"}}
-            ]}
-        ],
-        temperature=0.0,
-    )
-    return cleaner.clean_text(resp.choices[0].message.content, preserve_format=True)
-
-def process_audio(audio_path):
-    """Process audio with Whisper"""
-    with open(audio_path, "rb") as f:
-        transcription = openai_client.audio.transcriptions.create(model="whisper-1", file=f)
-    
-    cleaned_text = cleaner.clean_text(transcription.text)
-    st.session_state.messages.append({
-        "role": "user", 
-        "content": cleaned_text
-    })
-    return cleaned_text
+        b64 = base64.b64encode(open(file_path, "rb").read()).decode()
+        st.markdown(f'<a href="data:audio/mpeg;base64,{b64}" download="{file_path}">Download {file_path}</a>', unsafe_allow_html=True)
 
-def process_video(video_path, seconds_per_frame=1):
-    """Extract frames from video"""
-    # ... function remains the same as it handles binary data ...
-    [Your existing process_video implementation]
 
-def process_video_with_gpt(video_path, prompt):
-    """Analyze video frames with GPT-4V"""
-    frames = process_video(video_path)
-    cleaned_prompt = cleaner.clean_text(prompt)
-    
-    resp = openai_client.chat.completions.create(
-        model=st.session_state["openai_model"],
-        messages=[
-            {"role":"system","content":"Analyze video frames."},
-            {"role":"user","content":[
-                {"type":"text","text":cleaned_prompt},
-                *[{"type":"image_url","image_url":{"url":f"data:image/jpeg;base64,{fr}"}} 
-                  for fr in frames]
-            ]}
-        ]
-    )
-    return cleaner.clean_text(resp.choices[0].message.content, preserve_format=True)
-
-# 🤖 10. AI Model Integration
-def process_with_claude(text):
-    """Process text with Claude"""
-    if not text: return
-    
-    cleaned_input = cleaner.clean_text(text)
-    with st.chat_message("user"):
-        st.markdown(cleaned_input)
-        
-    with st.chat_message("assistant"):
-        r = claude_client.messages.create(
-            model="claude-3-sonnet-20240229",
-            max_tokens=1000,
-            messages=[{"role":"user","content":cleaned_input}]
-        )
-        raw_response = r.content[0].text
-        cleaned_response = cleaner.clean_text(raw_response, preserve_format=True)
-        
-        st.write("Claude-3.5: " + cleaned_response)
-        create_file(cleaned_input, cleaned_response, "md")
-        st.session_state.chat_history.append({
-            "user": cleaned_input,
-            "claude": cleaned_response
-        })
-    return cleaned_response
+async def edge_tts_generate_audio(text, voice="en-US-AriaNeural"):
+    out_fn = generate_filename(text, text, "mp3")
+    communicate = edge_tts.Communicate(text, voice)
+    await communicate.save(out_fn)
+    return out_fn
 
-def process_with_gpt(text):
-    """Process text with GPT-4"""
-    if not text: return
-    
-    cleaned_input = cleaner.clean_text(text)
-    st.session_state.messages.append({
-        "role": "user",
-        "content": cleaned_input
-    })
-    
-    with st.chat_message("user"):
-        st.markdown(cleaned_input)
-        
-    with st.chat_message("assistant"):
-        c = openai_client.chat.completions.create(
-            model=st.session_state["openai_model"],
-            messages=st.session_state.messages,
-            stream=False
-        )
-        raw_response = c.choices[0].message.content
-        cleaned_response = cleaner.clean_text(raw_response, preserve_format=True)
-        
-        st.write("GPT-4o: " + cleaned_response)
-        create_file(cleaned_input, cleaned_response, "md")
-        st.session_state.messages.append({
-            "role": "assistant",
-            "content": cleaned_response
-        })
-    return cleaned_response
 
-def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, titles_summary=True, full_audio=False):
-    """Perform Arxiv search and generate audio summaries"""
-    cleaned_query = cleaner.clean_text(q)
-    start = time.time()
-    
+# --- ArXiv Lookup ---
+def perform_ai_lookup(query, full_audio=False):
     client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-    refs = client.predict(cleaned_query, 20, "Semantic Search",
-                         "mistralai/Mixtral-8x7B-Instruct-v0.1",
-                         api_name="/update_with_rag_md")[0]
-    r2 = client.predict(cleaned_query, "mistralai/Mixtral-8x7B-Instruct-v0.1",
-                       True, api_name="/ask_llm")
-
-    # Clean responses
-    cleaned_r2 = cleaner.clean_text(r2, preserve_format=True)
-    cleaned_refs = cleaner.clean_text(refs, preserve_format=True)
-    
-    result = f"### 🔎 {cleaned_query}\n\n{cleaned_r2}\n\n{cleaned_refs}"
-    st.markdown(result)
-    
+    result = client.predict(query, api_name="/ask_llm")
+    st.markdown(f"### 🔎 {query}\n{result}")
     if full_audio:
-        complete_text = f"Complete response for query: {cleaned_query}. {clean_for_speech(cleaned_r2)} {clean_for_speech(cleaned_refs)}"
-        audio_file_full = speak_with_edge_tts(complete_text)
-        st.write("### 📚 Full Audio")
-        play_and_download_audio(audio_file_full)
-
-    if vocal_summary:
-        main_text = clean_for_speech(cleaned_r2)
-        audio_file_main = speak_with_edge_tts(main_text)
-        st.write("### 🎙 Short Audio")
-        play_and_download_audio(audio_file_main)
-
-    if extended_refs:
-        summaries_text = "Extended references: " + cleaned_refs.replace('"','')
-        summaries_text = clean_for_speech(summaries_text)
-        audio_file_refs = speak_with_edge_tts(summaries_text)
-        st.write("### 📜 Long Refs")
-        play_and_download_audio(audio_file_refs)
-
-    if titles_summary:
-        titles = []
-        for line in cleaned_refs.split('\n'):
-            m = re.search(r"\[([^\]]+)\]", line)
-            if m:
-                titles.append(m.group(1))
-        if titles:
-            titles_text = "Titles: " + ", ".join(titles)
-            titles_text = clean_for_speech(titles_text)
-            audio_file_titles = speak_with_edge_tts(titles_text)
-            st.write("### 🔖 Titles")
-            play_and_download_audio(audio_file_titles)
-
-    elapsed = time.time() - start
-    st.write(f"**Total Elapsed:** {elapsed:.2f} s")
+        audio_file = asyncio.run(edge_tts_generate_audio(result))
+        play_and_download_audio(audio_file)
+    create_file(query, result)
 
-    create_file(cleaned_query, result, "md")
-    return result
 
-def save_full_transcript(query, text):
-    """Save full transcript of results as a file."""
-    cleaned_query = cleaner.clean_text(query)
-    cleaned_text = cleaner.clean_text(text, preserve_format=True)
-    create_file(cleaned_query, cleaned_text, "md")
-
-# 📂 11. File Management
-def create_zip_of_files(md_files, mp3_files):
-    """Create zip with intelligent naming"""
-    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-    all_files = md_files + mp3_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:
-                content = file.read()
-                cleaned_content = cleaner.clean_text(content)
-                all_content.append(cleaned_content)
-        elif f.endswith('.mp3'):
-            all_content.append(os.path.basename(f))
-    
-    combined_content = " ".join(all_content)
-    info_terms = get_high_info_terms(combined_content)
-    
-    timestamp = datetime.now().strftime("%y%m_%H%M")
-    name_text = '_'.join(term.replace(' ', '-') for term in info_terms[:3])
-    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 load_files_for_sidebar():
-    """Load and group files for sidebar display"""
-    md_files = glob.glob("*.md")
-    mp3_files = glob.glob("*.mp3")
-
-    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-    all_files = md_files + mp3_files
-
-    groups = defaultdict(list)
-    for f in all_files:
-        fname = os.path.basename(f)
-        prefix = fname[:10]
-        groups[prefix].append(f)
-
-    for prefix in groups:
-        groups[prefix].sort(key=lambda x: os.path.getmtime(x), reverse=True)
-
-    sorted_prefixes = sorted(groups.keys(), 
-                           key=lambda pre: max(os.path.getmtime(x) for x in groups[pre]), 
-                           reverse=True)
-    return groups, sorted_prefixes
-
-def extract_keywords_from_md(files):
-    """Extract keywords from markdown files"""
-    text = ""
-    for f in files:
-        if f.endswith(".md"):
-            with open(f, 'r', encoding='utf-8') as file:
-                content = file.read()
-                cleaned_content = cleaner.clean_text(content)
-                text += " " + cleaned_content
-    return get_high_info_terms(text)
-
-def display_file_manager_sidebar(groups, sorted_prefixes):
-    """Display file manager in sidebar"""
-    st.sidebar.title("🎵 Audio & Docs Manager")
-
-    all_md = []
-    all_mp3 = []
-    for prefix in groups:
-        for f in groups[prefix]:
-            if f.endswith(".md"):
-                all_md.append(f)
-            elif f.endswith(".mp3"):
-                all_mp3.append(f)
-
-    top_bar = st.sidebar.columns(3)
-    with top_bar[0]:
-        if st.button("🗑 DelAllMD"):
-            for f in all_md:
-                os.remove(f)
-            st.session_state.should_rerun = True
-    with top_bar[1]:
-        if st.button("🗑 DelAllMP3"):
-            for f in all_mp3:
-                os.remove(f)
-            st.session_state.should_rerun = True
-    with top_bar[2]:
-        if st.button("⬇️ ZipAll"):
-            z = create_zip_of_files(all_md, all_mp3)
-            if z:
-                st.sidebar.markdown(get_download_link(z), unsafe_allow_html=True)
-
-    for prefix in sorted_prefixes:
-        files = groups[prefix]
-        kw = extract_keywords_from_md(files)
-        keywords_str = " ".join(kw) if kw else "No Keywords"
-        with st.sidebar.expander(f"{prefix} Files ({len(files)}) - KW: {keywords_str}", expanded=True):
-            c1, c2 = st.columns(2)
-            with c1:
-                if st.button("👀ViewGrp", key="view_group_"+prefix):
-                    st.session_state.viewing_prefix = prefix
-            with c2:
-                if st.button("🗑DelGrp", key="del_group_"+prefix):
-                    for f in files:
-                        os.remove(f)
-                    st.success(f"Deleted group {prefix}!")
-                    st.session_state.should_rerun = True
-
-            for f in files:
-                fname = os.path.basename(f)
-                ctime = datetime.fromtimestamp(os.path.getmtime(f)).strftime("%Y-%m-%d %H:%M:%S")
-                st.write(f"**{fname}** - {ctime}")
-
-# 🎯 12. Main Application
+# --- Main App ---
 def main():
-    st.sidebar.markdown("### 🚲BikeAI🏆 Multi-Agent Research")
-    tab_main = st.radio("Action:", ["🎤 Voice", "📸 Media", "🔍 ArXiv", "📝 Editor"], horizontal=True)
-
-    mycomponent = components.declare_component("mycomponent", path="mycomponent")
-    val = mycomponent(my_input_value="Hello")
-
-    # Show input in a text box for editing if detected
-    if val:
-        cleaned_val = cleaner.clean_text(val)
-        edited_input = st.text_area("✏️ Edit Input:", value=cleaned_val, height=100)
-        run_option = st.selectbox("Model:", ["Arxiv", "GPT-4o", "Claude-3.5"])
-        col1, col2 = st.columns(2)
-        with col1:
-            autorun = st.checkbox("⚙ AutoRun", value=True)
-        with col2:
-            full_audio = st.checkbox("📚FullAudio", value=False, 
-                                   help="Generate full audio response")
-
-        input_changed = (val != st.session_state.old_val)
-
-        if autorun and input_changed:
-            st.session_state.old_val = val
-            if run_option == "Arxiv":
-                perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
-                                titles_summary=True, full_audio=full_audio)
-            else:
-                if run_option == "GPT-4o":
-                    process_with_gpt(edited_input)
-                elif run_option == "Claude-3.5":
-                    process_with_claude(edited_input)
-        else:
-            if st.button("▶ Run"):
-                st.session_state.old_val = val
-                if run_option == "Arxiv":
-                    perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
-                                    titles_summary=True, full_audio=full_audio)
-                else:
-                    if run_option == "GPT-4o":
-                        process_with_gpt(edited_input)
-                    elif run_option == "Claude-3.5":
-                        process_with_claude(edited_input)
-
-    if tab_main == "🔍 ArXiv":
-        st.subheader("🔍 Query ArXiv")
-        q = st.text_input("🔍 Query:")
-        q = cleaner.clean_text(q)
-
-        st.markdown("### 🎛 Options")
-        vocal_summary = st.checkbox("🎙ShortAudio", value=True)
-        extended_refs = st.checkbox("📜LongRefs", value=False)
-        titles_summary = st.checkbox("🔖TitlesOnly", value=True)
-        full_audio = st.checkbox("📚FullAudio", value=False,
-                               help="Generate full audio response")
-        full_transcript = st.checkbox("🧾FullTranscript", value=False,
-                                    help="Generate a full transcript file")
-
-        if q and st.button("🔍Run"):
-            result = perform_ai_lookup(q, vocal_summary=vocal_summary, 
-                                     extended_refs=extended_refs,
-                                     titles_summary=titles_summary, 
-                                     full_audio=full_audio)
-            if full_transcript:
-                save_full_transcript(q, result)
-
-        st.markdown("### Change Prompt & Re-Run")
-        q_new = st.text_input("🔄 Modify Query:")
-        q_new = cleaner.clean_text(q_new)
-        if q_new and st.button("🔄 Re-Run with Modified Query"):
-            result = perform_ai_lookup(q_new, vocal_summary=vocal_summary,
-                                     extended_refs=extended_refs,
-                                     titles_summary=titles_summary,
-                                     full_audio=full_audio)
-            if full_transcript:
-                save_full_transcript(q_new, result)
-
-    elif tab_main == "🎤 Voice":
-        st.subheader("🎤 Voice Input")
-        user_text = st.text_area("💬 Message:", height=100)
-        user_text = cleaner.clean_text(user_text)
-        if st.button("📨 Send"):
-            process_with_gpt(user_text)
-        st.subheader("📜 Chat History")
-        t1, t2 = st.tabs(["Claude History", "GPT-4o History"])
-        with t1:
-            for c in st.session_state.chat_history:
-                st.write("**You:**", cleaner.clean_text(c["user"]))
-                st.write("**Claude:**", cleaner.clean_text(c["claude"], preserve_format=True))
-        with t2:
-            for m in st.session_state.messages:
-                with st.chat_message(m["role"]):
-                    if m["role"] == "user":
-                        st.markdown(cleaner.clean_text(m["content"]))
-                    else:
-                        st.markdown(cleaner.clean_text(m["content"], preserve_format=True))
-
-    elif tab_main == "📸 Media":
-        st.header("📸 Images & 🎥 Videos")
-        tabs = st.tabs(["🖼 Images", "🎥 Video"])
-        with tabs[0]:
-            imgs = glob.glob("*.png") + glob.glob("*.jpg")
-            if imgs:
-                c = st.slider("Cols", 1, 5, 3)
-                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}"):
-                            a = process_image(f, "Describe this image.")
-                            st.markdown(cleaner.clean_text(a, preserve_format=True))
-            else:
-                st.write("No images found.")
-        with tabs[1]:
-            vids = glob.glob("*.mp4")
-            if vids:
-                for v in vids:
-                    with st.expander(f"🎥 {os.path.basename(v)}"):
-                        st.video(v)
-                        if st.button(f"Analyze {os.path.basename(v)}", key=f"analyze_{v}"):
-                            a = process_video_with_gpt(v, "Describe video.")
-                            st.markdown(cleaner.clean_text(a, preserve_format=True))
-            else:
-                st.write("No videos found.")
-
-    elif tab_main == "📝 Editor":
-        if getattr(st.session_state, 'current_file', None):
-            st.subheader(f"Editing: {st.session_state.current_file}")
-            with open(st.session_state.current_file, 'r', encoding='utf-8') as f:
-                content = f.read()
-            content = cleaner.clean_text(content, preserve_format=True)
-            new_text = st.text_area("✏️ Content:", content, height=300)
-            if st.button("💾 Save"):
-                cleaned_content = cleaner.clean_text(new_text, preserve_format=True)
-                with open(st.session_state.current_file, 'w', encoding='utf-8') as f:
-                    f.write(cleaned_content)
-                st.success("Updated!")
-                st.session_state.should_rerun = True
-        else:
-            st.write("Select a file from the sidebar to edit.")
-
-    groups, sorted_prefixes = load_files_for_sidebar()
-    display_file_manager_sidebar(groups, sorted_prefixes)
+    st.sidebar.title("📂 File Manager")
+    action = st.radio("Action:", ["🎤 Voice", "🔍 ArXiv"])
+    if action == "🔍 ArXiv":
+        query = st.text_input("Query")
+        if st.button("Run"):
+            perform_ai_lookup(query)
 
-    if st.session_state.viewing_prefix and st.session_state.viewing_prefix in groups:
-        st.write("---")
-        st.write(f"**Viewing Group:** {st.session_state.viewing_prefix}")
-        for f in groups[st.session_state.viewing_prefix]:
-            fname = os.path.basename(f)
-            ext = os.path.splitext(fname)[1].lower().strip('.')
-            st.write(f"### {fname}")
-            if ext == "md":
-                with open(f, 'r', encoding='utf-8') as file:
-                    content = file.read()
-                st.markdown(cleaner.clean_text(content, preserve_format=True))
-            elif ext == "mp3":
-                st.audio(f)
-            else:
-                st.markdown(get_download_link(f), unsafe_allow_html=True)
-        if st.button("❌ Close"):
-            st.session_state.viewing_prefix = None
+    elif action == "🎤 Voice":
+        text = st.text_area("Message")
+        if st.button("Send"):
+            process_with_gpt(text)
 
-    if st.session_state.should_rerun:
-        st.session_state.should_rerun = False
-        st.rerun()
 
 if __name__ == "__main__":
-    main()
+    main()