Update app.py

app.py

@@ -1,5 +1,5 @@
 import streamlit as st
-from streamlit.components.v1 import html
+from streamlit.components.v1 import components
 from pathlib import Path
 import json
 import time
@@ -7,322 +7,232 @@ from datetime import datetime
 import re
 import pandas as pd
 import yaml
-from io import StringIO
+from io import StringIO, BytesIO
 import openpyxl
 import csv
 import base64
 import glob
 import os
-
-# File type definitions
-FILE_TYPES = {
-    "md": "📝 Markdown",
-    "txt": "📄 Text",
-    "json": "🔧 JSON",
-    "csv": "📊 CSV",
-    "xlsx": "📗 Excel",
-    "yaml": "⚙️ YAML",
-    "xml": "🔗 XML"
-}
-
-# Initialize session state
-for key in ['file_data', 'file_types', 'md_outline', 'rendered_content', 
-           'file_history', 'md_versions', 'md_files_history', 'combined_markdown']:
-    if key not in st.session_state:
-        st.session_state[key] = {} if key in ['file_data', 'file_types', 'md_outline', 
-                                            'rendered_content', 'md_versions'] else [] if key in ['file_history', 
-                                            'md_files_history'] else ""
-
-def encode_content(content):
-    """Encode content to base64"""
-    return base64.b64encode(content.encode()).decode()
-
-def decode_content(encoded_content):
-    """Decode content from base64"""
-    return base64.b64decode(encoded_content.encode()).decode()
-
-def parse_markdown_outline(content):
-    """Generate an outline from markdown content"""
-    return [{'level': len(line.split()[0]), 'title': line.strip('#').strip(), 
-             'indent': '    ' * (len(line.split()[0]) - 1)} 
-            for line in content.split('\n') if line.strip().startswith('#')]
-
-def get_binary_file_downloader_html(bin_file, file_label='File'):
-    """Generate download link"""
-    b64 = encode_content(bin_file)
-    return f'<a href="data:text/plain;base64,{b64}" download="{file_label}">📥 Download {file_label}</a>'
-
-def add_to_history(filename, content, action="uploaded"):
-    """Add a file action to history with timestamp"""
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    encoded_content = encode_content(content)
+import zipfile
+
+# Initialize session state for chat history if not exists
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+if 'messages' not in st.session_state:
+    st.session_state.messages = []
+if 'current_file' not in st.session_state:
+    st.session_state.current_file = None
+if 'file_content' not in st.session_state:
+    st.session_state.file_content = None
+
+def create_zip_of_files(files):
+    """Create a zip file containing all markdown files"""
+    zip_buffer = BytesIO()
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        for file in files:
+            with open(file, 'r', encoding='utf-8') as f:
+                zip_file.writestr(file, f.read())
+    return zip_buffer.getvalue()
+
+def get_download_link(file_path):
+    """Create a download link for a file"""
+    if isinstance(file_path, bytes):  # For zip files
+        b64 = base64.b64encode(file_path).decode()
+        href = f'data:application/zip;base64,{b64}'
+        filename = 'all_files.zip'
+    else:  # For individual files
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        b64 = base64.b64encode(content.encode()).decode()
+        href = f'data:text/markdown;base64,{b64}'
+        filename = os.path.basename(file_path)
+    return f'<a href="{href}" download="{filename}">{filename}</a>'
+
+def load_file(filepath):
+    """Load file content"""
+    with open(filepath, 'r', encoding='utf-8') as f:
+        return f.read()
+
+def display_file_manager():
+    """Display file management sidebar with guaranteed unique button keys."""
+    st.sidebar.title("📁 File Management")
+    all_files = glob.glob("*.md")
+    all_files.sort(reverse=True)
     
-    st.session_state.file_history.insert(0, {
-        "timestamp": timestamp,
-        "filename": filename,
-        "action": action,
-        "content": encoded_content
-    })
+    if st.sidebar.button("🗑 Delete All", key="delete_all_files_button"):
+        for file in all_files:
+            os.remove(file)
+        st.rerun()
     
-    if filename.endswith('.md'):
-        if filename not in st.session_state.md_versions:
-            st.session_state.md_versions[filename] = []
-            
-        st.session_state.md_versions[filename].append({
-            "timestamp": timestamp,
-            "content": encoded_content,
-            "action": action
-        })
-        
-        if filename not in [f["filename"] for f in st.session_state.md_files_history]:
-            st.session_state.md_files_history.append({
-                "filename": filename,
-                "timestamp": timestamp,
-                "content": encoded_content
-            })
-        
-        st.session_state.combined_markdown = combine_markdown_files()
-
-def combine_markdown_files():
-    """Combine markdown files into a single document"""
-    return "".join([f"# {md_file['filename']}\n\n{decode_content(md_file['content'])}\n\n---\n\n" 
-                   for md_file in sorted(st.session_state.md_files_history, 
-                   key=lambda x: x["filename"])])
-
-def scan_and_load_files():
-    """Scan directory for supported files and load them"""
-    loaded_files = []
-    for ext in FILE_TYPES.keys():
-        for filepath in glob.glob(f"*.{ext}"):
-            try:
-                with open(filepath, 'r', encoding='utf-8') as f:
-                    content = f.read()
-                    file_type = filepath.split('.')[-1].lower()
-                    
-                    st.session_state.file_data[filepath] = content
-                    st.session_state.file_types[filepath] = file_type
-                    
-                    if file_type == 'md':
-                        st.session_state.md_outline[filepath] = parse_markdown_outline(content)
-                        st.session_state.rendered_content[filepath] = content
-                        if filepath not in [f["filename"] for f in st.session_state.md_files_history]:
-                            add_to_history(filepath, content, "auto-loaded")
-                    
-                    loaded_files.append(filepath)
-            except Exception as e:
-                st.error(f"🚨 Error loading {filepath}: {str(e)}")
+    if st.sidebar.button("⬇️ Download All", key="download_all_files_button"):
+        zip_file = create_zip_of_files(all_files)
+        st.sidebar.markdown(get_download_link(zip_file), unsafe_allow_html=True)
     
-    return loaded_files
-
-def show_markdown_versions(filename):
-    """Display previous versions of a markdown file"""
-    if filename in st.session_state.md_versions and len(st.session_state.md_versions[filename]) > 1:
-        st.markdown("### 📚 Previous Versions")
-        version_idx = st.selectbox(
-            "Select version to view",
-            range(len(st.session_state.md_versions[filename])-1),
-            format_func=lambda x: f"Version {len(st.session_state.md_versions[filename])-1-x} - {st.session_state.md_versions[filename][x]['timestamp']}"
-        )
+    for idx, file in enumerate(all_files):
+        file_stat = os.stat(file)
+        unique_id = f"{idx}_{file_stat.st_size}_{file_stat.st_mtime}"
         
-        if version_idx is not None:
-            version = st.session_state.md_versions[filename][version_idx]
-            decoded_content = decode_content(version['content'])
-            st.text_area("Content", decoded_content, height=200, 
-                        key=f"version_{filename}_{version_idx}", disabled=True)
-            
-            if st.button(f"Restore to this version", key=f"restore_{filename}_{version_idx}"):
-                st.session_state.file_data[filename] = decoded_content
-                st.session_state.md_outline[filename] = parse_markdown_outline(decoded_content)
-                add_to_history(filename, decoded_content, "restored")
+        col1, col2, col3, col4 = st.sidebar.columns([1,3,1,1])
+        with col1:
+            if st.button("🌐", key=f"view_{unique_id}"):
+                st.session_state.current_file = file
+                st.session_state.file_content = load_file(file)
+        with col2:
+            st.markdown(get_download_link(file), unsafe_allow_html=True)
+        with col3:
+            if st.button("📂", key=f"edit_{unique_id}"):
+                st.session_state.current_file = file
+                st.session_state.file_content = load_file(file)
+        with col4:
+            if st.button("🗑", key=f"delete_{unique_id}"):
+                os.remove(file)
                 st.rerun()
 
-def create_markdown_tabs(content, filename):
-    """Create tabs for markdown content viewing and editing"""
-    tab1, tab2, tab3 = st.tabs(["📝 Editor", "👀 Preview", "🕒 History"])
+def process_with_gpt(user_input):
+    """Process input with GPT-4"""
+    # Add your GPT processing logic here
+    response = f"GPT-4 Response to: {user_input}"
+    st.session_state.messages.append({"role": "user", "content": user_input})
+    st.session_state.messages.append({"role": "assistant", "content": response})
+    return response
+
+def process_with_claude(user_input):
+    """Process input with Claude"""
+    # Add your Claude processing logic here
+    response = f"Claude Response to: {user_input}"
+    st.session_state.chat_history.append({
+        "user": user_input,
+        "claude": response
+    })
+    return response
+
+def perform_ai_lookup(query):
+    """Perform AI lookup with ArXiv"""
+    # Add your ArXiv lookup logic here
+    return f"ArXiv results for: {query}"
+
+def search_arxiv(query):
+    """Search ArXiv papers"""
+    # Add your ArXiv search logic here
+    return f"ArXiv search results for: {query}"
+
+def create_media_gallery():
+    """Create media gallery interface"""
+    st.subheader("Media Gallery")
+    st.write("Media gallery functionality goes here")
+
+def show_chat_history():
+    """Display chat history for both models"""
+    st.subheader("Chat History 📜")
+    tab1, tab2 = st.tabs(["Claude History", "GPT-4o History"])
     
     with tab1:
-        edited_content = st.text_area("Edit your markdown", content, height=300, 
-                                    key=f"edit_{filename}")
-        if edited_content != content:
-            st.session_state.file_data[filename] = edited_content
-            st.session_state.md_outline[filename] = parse_markdown_outline(edited_content)
-            add_to_history(filename, edited_content, "edited")
-            content = edited_content
+        for chat in st.session_state.chat_history:
+            st.text_area("You:", chat["user"], height=100)
+            st.text_area("Claude:", chat["claude"], height=200)
+            st.markdown(chat["claude"])
     
     with tab2:
-        st.markdown("### Preview")
-        st.markdown(content)
-        if filename in st.session_state.md_outline:
-            st.markdown("---\n### 📑 Document Outline")
-            for item in st.session_state.md_outline[filename]:
-                st.markdown(f"{item['indent']}• {item['title']}")
+        for message in st.session_state.messages:
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
+
+def handle_voice_input(model_choice):
+    """Handle voice input tab logic"""
+    st.subheader("Voice Recognition")
+    if 'voice_transcript' not in st.session_state:
+        st.session_state.voice_transcript = ""
     
-    with tab3:
-        show_markdown_versions(filename)
+    user_input = st.text_area("Message:", height=100)
+    if st.button("Send 📨") and user_input:
+        process_ai_input(user_input, model_choice)
     
-    return content
-
-def show_sidebar_history():
-    """Display markdown file history in sidebar"""
-    st.sidebar.markdown("### 📚 Markdown Files History")
-    
-    if st.sidebar.button("🗑️ Delete All (except README.md)"):
-        files_to_remove = [f for f in st.session_state.md_files_history if f["filename"] != "README.md"]
-        for file in files_to_remove:
-            filename = file["filename"]
-            for key in ['file_data', 'file_types', 'md_outline', 'rendered_content', 'md_versions']:
-                if filename in st.session_state[key]:
-                    del st.session_state[key][filename]
-        
-        st.session_state.md_files_history = [f for f in st.session_state.md_files_history 
-                                           if f["filename"] == "README.md"]
-        st.session_state.combined_markdown = ""
-        st.sidebar.success(f"Deleted {len(files_to_remove)} markdown files")
-        st.rerun()
-    
-    for md_file in st.session_state.md_files_history:
-        col1, col2, col3 = st.sidebar.columns([2, 1, 1])
-        with col1:
-            st.markdown(f"**{md_file['filename']}**")
+    show_chat_history()
+
+def handle_file_editor():
+    """Handle file editor tab logic"""
+    if st.session_state.current_file:
+        st.subheader(f"Editing: {st.session_state.current_file}")
+        new_content = st.text_area("Content:", st.session_state.file_content, height=300)
+        if st.button("Save Changes"):
+            with open(st.session_state.current_file, 'w', encoding='utf-8') as file:
+                file.write(new_content)
+            st.success("File updated successfully!")
+
+def process_ai_input(user_input, model_choice):
+    """Handle AI processing based on model choice"""
+    if model_choice == "GPT-4o":
+        gpt_response = process_with_gpt(user_input)
+    elif model_choice == "Claude-3":
+        claude_response = process_with_claude(user_input)
+    else:  # All Three AIs
+        col1, col2, col3 = st.columns(3)
         with col2:
-            if st.button("📂", key=f"open_{md_file['filename']}"):
-                content = decode_content(md_file['content'])
-                st.session_state.file_data[md_file['filename']] = content
-                st.session_state.file_types[md_file['filename']] = "md"
-                st.session_state.md_outline[md_file['filename']] = parse_markdown_outline(content)
-                st.rerun()
+            st.subheader("Claude-3.5 Sonnet:")
+            try:
+                claude_response = process_with_claude(user_input)
+            except:
+                st.write('Claude 3.5 Sonnet out of tokens.')
+        with col1:
+            st.subheader("GPT-4o Omni:")
+            try:
+                gpt_response = process_with_gpt(user_input)
+            except:
+                st.write('GPT 4o out of tokens')
         with col3:
-            st.markdown(get_binary_file_downloader_html(
-                decode_content(md_file['content']), md_file['filename']), unsafe_allow_html=True)
-
-def show_file_history():
-    """Display file history in collapsible section"""
-    if st.session_state.file_history:
-        with st.expander("📋 File History", expanded=False):
-            st.markdown("### Recent File Activities")
-            for entry in st.session_state.file_history:
-                col1, col2 = st.columns([2, 3])
-                with col1:
-                    st.markdown(f"**{entry['timestamp']}**")
-                with col2:
-                    st.markdown(f"{entry['action'].title()}: {entry['filename']}")
-
-def read_file_content(uploaded_file):
-    """Smart file reader with enhanced markdown handling"""
-    file_type = uploaded_file.name.split('.')[-1].lower()
-    try:
-        if file_type == 'md':
-            content = uploaded_file.getvalue().decode()
-            st.session_state.md_outline[uploaded_file.name] = parse_markdown_outline(content)
-            st.session_state.rendered_content[uploaded_file.name] = content
-            add_to_history(uploaded_file.name, content)
-            return content, "md"
-        elif file_type in ['csv', 'xlsx']:
-            df = pd.read_csv(uploaded_file) if file_type == 'csv' else pd.read_excel(uploaded_file)
-            return df.to_string(), file_type
-        elif file_type == 'json':
-            return json.dumps(json.load(uploaded_file), indent=2), "json"
-        elif file_type == 'yaml':
-            return yaml.dump(yaml.safe_load(uploaded_file)), "yaml"
-        else:
-            return uploaded_file.getvalue().decode(), "txt"
-    except Exception as e:
-        st.error(f"🚨 Error reading {uploaded_file.name}: {str(e)}")
-        return None, None
-
-def save_file_content(content, filename, file_type):
-    """Smart file saver with enhanced markdown handling"""
-    try:
-        if file_type == "md":
-            with open(filename, 'w') as f:
-                f.write(content)
-            st.session_state.rendered_content[filename] = content
-            add_to_history(filename, content, "saved")
-        elif file_type in ["csv", "xlsx"]:
-            df = pd.read_csv(StringIO(content)) if file_type == "csv" else pd.read_excel(StringIO(content))
-            df.to_csv(filename, index=False) if file_type == "csv" else df.to_excel(filename, index=False)
-        elif file_type == "json":
-            with open(filename, 'w') as f:
-                json.dump(json.loads(content), f, indent=2)
-        elif file_type == "yaml":
-            with open(filename, 'w') as f:
-                yaml.dump(yaml.safe_load(content), f)
-        else:
-            with open(filename, 'w') as f:
-                f.write(content)
-        return True
-    except Exception as e:
-        st.error(f"🚨 Error saving {filename}: {str(e)}")
-        return False
+            st.subheader("Arxiv and Mistral Research:")
+            with st.spinner("Searching ArXiv..."):
+                try:
+                    results = perform_ai_lookup(user_input)
+                    st.markdown(results)
+                except:
+                    st.write("Arxiv Mistral too busy - try again.")
+
+def handle_arxiv_search():
+    """Handle ArXiv search tab logic"""
+    query = st.text_input("Enter your research query:")
+    if query:
+        with st.spinner("Searching ArXiv..."):
+            results = search_arxiv(query)
+            st.markdown(results)
 
 def main():
-    # Perform initial file scan
-    loaded_files = scan_and_load_files()
+    st.sidebar.markdown("### 🚲BikeAI🏆 Claude and GPT Multi-Agent Research AI")
     
-    st.title("📚✨ Super Smart File Handler with Markdown Magic! ✨📚")
-    show_sidebar_history()
+    # Display file manager in sidebar first
+    display_file_manager()
     
-    upload_tab, book_tab = st.tabs(["📤 File Upload", "📖 Book View"])
+    # Model Selection
+    model_choice = st.sidebar.radio(
+        "Choose AI Model:",
+        ["GPT+Claude+Arxiv", "GPT-4o", "Claude-3"]
+    )
     
-    with upload_tab:
-        col1, col2 = st.columns(2)
-        with col1:
-            single_uploaded_file = st.file_uploader(
-                "📤 Upload single file", 
-                type=list(FILE_TYPES.keys()),
-                help="Supports: " + ", ".join([f"{v} (.{k})" for k, v in FILE_TYPES.items()]),
-                key="single_uploader"
-            )
-        
-        with col2:
-            multiple_uploaded_files = st.file_uploader(
-                "📚 Upload multiple files",
-                type=list(FILE_TYPES.keys()),
-                accept_multiple_files=True,
-                help="Upload multiple files to view as a book",
-                key="multiple_uploader"
-            )
-        
-        if single_uploaded_file:
-            content, file_type = read_file_content(single_uploaded_file)
-            if content is not None:
-                st.session_state.file_data[single_uploaded_file.name] = content
-                st.session_state.file_types[single_uploaded_file.name] = file_type
-                st.success(f"🎉 Loaded {FILE_TYPES.get(file_type, '📄')} file: {single_uploaded_file.name}")
-        
-        if multiple_uploaded_files:
-            for uploaded_file in multiple_uploaded_files:
-                content, file_type = read_file_content(uploaded_file)
-                if content is not None:
-                    st.session_state.file_data[uploaded_file.name] = content
-                    st.session_state.file_types[uploaded_file.name] = file_type
-            st.success(f"🎉 Loaded {len(multiple_uploaded_files)} files")
-            st.rerun()
-        
-        show_file_history()
+    # Main navigation
+    tab_main = st.radio("Choose Action:", 
+                       ["🎤 Voice Input", "📸 Media Gallery", "🔍 Search ArXiv", "📝 File Editor"],
+                       horizontal=True)
+
+    try:
+        # Component Magic section - wrapped in try/except in case component isn't available
+        mycomponent = components.declare_component("mycomponent", path="mycomponent")
+        value = mycomponent(my_input_value="hello there")
+        st.write("Received", value)
         
-        if st.session_state.file_data:
-            st.subheader("📂 Your Files")
-            for filename, content in st.session_state.file_data.items():
-                file_type = st.session_state.file_types[filename]
-                with st.expander(f"{FILE_TYPES.get(file_type, '📄')} {filename}"):
-                    if file_type == "md":
-                        content = create_markdown_tabs(content, filename)
-                    else:
-                        edited_content = st.text_area(
-                            "Content", content, height=300, key=f"edit_{filename}")
-                        if edited_content != content:
-                            st.session_state.file_data[filename] = edited_content
-                            content = edited_content
-                    
-                    if st.button(f"💾 Save {filename}"):
-                        if save_file_content(content, filename, file_type):
-                            st.success(f"✨ Saved {filename} successfully!")
-    
-    with book_tab:
-        if st.session_state.combined_markdown:
-            st.markdown("## 📖 Book View")
-            st.markdown(st.session_state.combined_markdown)
+        if value is not None:
+            process_ai_input(value, model_choice)
+    except:
+        st.warning("Voice component not available")
+
+    # Handle main tab navigation
+    if tab_main == "🎤 Voice Input":
+        handle_voice_input(model_choice)
+    elif tab_main == "📸 Media Gallery":
+        create_media_gallery()
+    elif tab_main == "🔍 Search ArXiv":
+        handle_arxiv_search()
+    elif tab_main == "📝 File Editor":
+        handle_file_editor()
 
 if __name__ == "__main__":
     main()