Update app.py

app.py

@@ -356,259 +356,149 @@ def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, titles_summary
     st.write(f"**Total Elapsed:** {elapsed:.2f} s")
     
     return response
-
 def render_search_interface():
     """Main search interface with voice recognition and model selection"""
     st.header("🔍 Voice Search & Research")
-    
-    # Voice and model settings
 
-    col1, col2, col3 = st.columns([2, 1, 1])
-    with col1:
-        selected_voice = st.selectbox(
-            "Select Voice",
-            ENGLISH_VOICES,
-            index=0,
-            help="Choose the voice for audio responses"
-        )
-    with col2:
-        run_option = st.selectbox(
-            "Model:",
-            ["Arxiv", "GPT-4o", "Claude-3.5"],
-            key="run_option"
-        )
-    with col3:
-        autorun = st.checkbox("⚙ AutoRun", value=True, key="autorun")
-    
-    # Voice component
-    voice_result = create_voice_component()
-    
-    # Handle voice input with autorun
-    if voice_result and isinstance(voice_result, (str, dict)):
-        # Extract text and trigger info
-        if isinstance(voice_result, dict):
-            current_text = voice_result.get('text', '')
-            trigger = voice_result.get('trigger')
-        else:
-            current_text = voice_result
-            trigger = None
-        
-        # Show text in edit box
-        edited_input = st.text_area(
-            "✏️ Edit Input:",
-            value=current_text,
-            height=100,
-            key="edited_input"
-        )
-        
-        # Check if input has changed
-        input_changed = (edited_input != st.session_state.get('last_processed_text', ''))
-        
-        # Process based on autorun and model selection
-        if autorun and input_changed and edited_input:
-            st.session_state.last_processed_text = edited_input
-            
-            try:
-                with st.spinner("Processing..."):
-                    if run_option == "Arxiv":
-                        result = perform_ai_lookup(
-                            edited_input,
-                            vocal_summary=True,
-                            extended_refs=False,
-                            titles_summary=True,
-                            full_audio=True,
-                            voice=selected_voice
-                        )
-                    elif run_option == "GPT-4o":
-                        result = process_with_gpt(edited_input)
-                        # Generate audio for GPT response
-                        audio_file = asyncio.run(generate_audio(result, voice=selected_voice))
-                        if audio_file:
-                            render_audio_result(audio_file, "GPT-4 Response")
-                    elif run_option == "Claude-3.5":
-                        result = process_with_claude(edited_input)
-                        # Generate audio for Claude response
-                        audio_file = asyncio.run(generate_audio(result, voice=selected_voice))
-                        if audio_file:
-                            render_audio_result(audio_file, "Claude Response")
-                    
-                    # Save to history
-                    st.session_state.transcript_history.append({
-                        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                        'query': edited_input,
-                        'response': result,
-                        'model': run_option
-                    })
-            
-            except Exception as e:
-                st.error(f"Error processing request: {str(e)}")
+    # Get voice component value and set up model selection
+    mycomponent = components.declare_component("mycomponent", path="mycomponent")
+    val = mycomponent(my_input_value="Hello")
+
+    # Show input in edit box if detected
+    if val:
+        val_stripped = val.replace('\n', ' ')
+        edited_input = st.text_area("✏️ Edit Input:", value=val_stripped, height=100)
+        run_option = st.selectbox("Model:", ["Arxiv", "GPT-4o", "Claude-3.5"])
         
-        # Manual run button
-        elif st.button("▶ Run"):
-            try:
-                with st.spinner("Processing..."):
-                    if run_option == "Arxiv":
-                        result = perform_ai_lookup(
-                            edited_input,
-                            vocal_summary=True,
-                            extended_refs=False,
-                            titles_summary=True,
-                            full_audio=True,
-                            voice=selected_voice
-                        )
-                    elif run_option == "GPT-4o":
-                        result = process_with_gpt(edited_input)
-                        audio_file = asyncio.run(generate_audio(result, voice=selected_voice))
-                        if audio_file:
-                            render_audio_result(audio_file, "GPT-4 Response")
+        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.get('old_val', None))
+
+        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":
-                        result = process_with_claude(edited_input)
-                        audio_file = asyncio.run(generate_audio(result, voice=selected_voice))
-                        if audio_file:
-                            render_audio_result(audio_file, "Claude Response")
-                    
-                    # Save to history
-                    st.session_state.transcript_history.append({
-                        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                        'query': edited_input,
-                        'response': result,
-                        'model': run_option
-                    })
-            
-            except Exception as e:
-                st.error(f"Error processing request: {str(e)}")
+                        process_with_claude(edited_input)
 
+                        
 def main():
-    st.title("🔬 ARIA Research Assistant")
-    
-    # Initialize settings
-    with st.sidebar:
-        st.title("⚙️ Settings")
-        
-        # Audio Settings
-        st.subheader("Audio Settings")
-        st.session_state.autoplay_audio = st.checkbox(
-            "Autoplay Audio",
-            value=True,
-            help="Automatically play audio when generated"
-        )
-        
-        rate = st.slider("Speech Rate", -50, 50, 0, 5)
-        pitch = st.slider("Pitch", -50, 50, 0, 5)
-        
-        # Advanced Settings
-        st.subheader("Advanced")
-        save_history = st.checkbox(
-            "Save History",
-            value=True,
-            help="Save transcripts and responses"
-        )
-        cleanup_old = st.checkbox(
-            "Auto Cleanup",
-            value=False,
-            help="Remove old files automatically"
-        )
-    
-    # Main content tabs
-    tabs = st.tabs(["🎤 Voice Search", "📚 History", "🎵 Media", "⚙️ Advanced"])
-    
-    with tabs[0]:
+    st.sidebar.markdown("### 🚲BikeAI🏆 Multi-Agent Research")
+    tab_main = st.radio("Action:", ["🎤 Voice", "📸 Media", "🔍 ArXiv", "📝 Editor"], horizontal=True)
+
+    if tab_main == "🎤 Voice":
         render_search_interface()
-    
-    with tabs[1]:
-        st.header("Search History")
-        if st.session_state.transcript_history:
-            for entry in reversed(st.session_state.transcript_history):
-                with st.expander(
-                    f"🔍 {entry['timestamp']} - {entry['query'][:50]}...",
-                    expanded=False
-                ):
-                    st.markdown(f"**Model:** {entry['model']}")
-                    st.markdown(entry['response'])
-    
-    with tabs[2]:
-        st.header("Media Files")
-        media_tabs = st.tabs(["🎵 Audio", "🎥 Video", "📷 Images"])
-        
-        with media_tabs[0]:
-            audio_files = glob.glob("*.mp3")
-            if audio_files:
-                for audio_file in sorted(audio_files, key=os.path.getmtime, reverse=True):
-                    st.markdown(get_audio_autoplay_html(audio_file), unsafe_allow_html=True)
-            else:
-                st.write("No audio files found")
+
+    elif tab_main == "🔍 ArXiv":
+        st.subheader("🔍 Query ArXiv")
+        q = st.text_input("🔍 Query:")
+
+        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="Full audio of results")
+        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:")
+        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 == "📸 Media":
+        st.header("📸 Images & 🎥 Videos")
+        tabs = st.tabs(["🖼 Images", "🎥 Video"])
         
-        with media_tabs[1]:
-            video_files = glob.glob("*.mp4")
-            if video_files:
-                cols = st.columns(2)
-                for idx, video_file in enumerate(video_files):
-                    with cols[idx % 2]:
-                        st.video(video_file)
+        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(a)
             else:
-                st.write("No video files found")
-        
-        with media_tabs[2]:
-            image_files = glob.glob("*.png") + glob.glob("*.jpg")
-            if image_files:
-                cols = st.columns(3)
-                for idx, image_file in enumerate(image_files):
-                    with cols[idx % 3]:
-                        st.image(Image.open(image_file), use_column_width=True)
+                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(a)
             else:
-                st.write("No images found")
-    
-    with tabs[3]:
-        st.header("Advanced Settings")
-        
-        col1, col2 = st.columns(2)
-        with col1:
-            st.subheader("Model Settings")
-            st.selectbox(
-                "Default Model",
-                ["Arxiv", "GPT-4o", "Claude-3.5"],
-                key="default_model"
-            )
-            st.number_input(
-                "Max Response Length",
-                min_value=100,
-                max_value=2000,
-                value=1000,
-                key="max_tokens"
-            )
-        
-        with col2:
-            st.subheader("Voice Settings")
-            st.slider(
-                "Pause Detection (ms)",
-                min_value=500,
-                max_value=3000,
-                value=1500,
-                step=100,
-                key="pause_threshold"
-            )
-            st.checkbox(
-                "High Quality Voice",
-                value=True,
-                key="high_quality_audio"
-            )
+                st.write("No videos found.")
 
-# Cleanup utility
-def cleanup_old_files(days=7):
-    """Remove files older than specified days"""
-    current_time = time.time()
-    for pattern in ["*.md", "*.mp3"]:
-        for f in glob.glob(pattern):
-            creation_time = os.path.getctime(f)
-            if (current_time - creation_time) // (24 * 3600) >= days:
-                try:
-                    os.remove(f)
-                except:
-                    pass
+    elif tab_main == "📝 Editor":
+        if getattr(st.session_state,'current_file',None):
+            st.subheader(f"Editing: {st.session_state.current_file}")
+            new_text = st.text_area("✏️ Content:", st.session_state.file_content, height=300)
+            if st.button("💾 Save"):
+                with open(st.session_state.current_file,'w',encoding='utf-8') as f:
+                    f.write(new_text)
+                st.success("Updated!")
+                st.session_state.should_rerun = True
+        else:
+            st.write("Select a file from the sidebar to edit.")
 
-if __name__ == "__main__":
-    if st.session_state.get('cleanup_enabled', False):
-        cleanup_old_files()
-    main()
+    groups, sorted_prefixes = load_files_for_sidebar()
+    display_file_manager_sidebar(groups, sorted_prefixes)
+
+    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":
+                content = open(f,'r',encoding='utf-8').read()
+                st.markdown(content)
+            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
 
+    if st.session_state.should_rerun:
+        st.session_state.should_rerun = False
+        st.rerun()