Update app.py

app.py

@@ -1,5 +1,5 @@
 import streamlit as st
-from streamlit.components.v1 import components
+from streamlit.components.v1 import html
 from pathlib import Path
 import json
 import time
@@ -15,18 +15,28 @@ import glob
 import os
 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
+# 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',
+           'current_file', 'file_content']:
+    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 None if key in ['current_file', 'file_content'] else ""
 
 def create_zip_of_files(files):
-    """Create a zip file containing all markdown files"""
+    """Create a zip file containing all files"""
     zip_buffer = BytesIO()
     with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
         for file in files:
@@ -53,21 +63,51 @@ def load_file(filepath):
     with open(filepath, 'r', encoding='utf-8') as f:
         return f.read()
 
+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 combine_markdown_files():
+    """Combine markdown files into a single document"""
+    all_files = glob.glob("*.md")
+    combined = []
+    for filepath in sorted(all_files):
+        with open(filepath, 'r', encoding='utf-8') as f:
+            content = f.read()
+            combined.append(f"# {filepath}\n\n{content}\n\n---\n\n")
+    return "".join(combined)
+
 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)
     
-    if st.sidebar.button("🗑 Delete All", key="delete_all_files_button"):
-        for file in all_files:
-            os.remove(file)
-        st.rerun()
+    col1, col2 = st.sidebar.columns(2)
+    with col1:
+        if st.button("🗑 Delete All", key="delete_all_files_button"):
+            for file in all_files:
+                if file != "README.md":  # Protect README.md
+                    os.remove(file)
+            st.rerun()
+    with col2:
+        if st.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)
     
-    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)
+    st.sidebar.markdown("---")
     
+    # Create unique keys using file attributes
     for idx, file in enumerate(all_files):
         file_stat = os.stat(file)
         unique_id = f"{idx}_{file_stat.st_size}_{file_stat.st_mtime}"
@@ -88,151 +128,105 @@ def display_file_manager():
                 os.remove(file)
                 st.rerun()
 
-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"])
+def create_markdown_tabs(content, filename):
+    """Create tabs for markdown content viewing and editing"""
+    tab1, tab2 = st.tabs(["📝 Editor", "👀 Preview"])
     
     with tab1:
-        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"])
+        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
+            content = edited_content
+            
+        if st.button("💾 Save"):
+            with open(filename, 'w', encoding='utf-8') as f:
+                f.write(edited_content)
+            st.success("✨ Saved successfully!")
     
     with tab2:
-        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 = ""
+        st.markdown(content, unsafe_allow_html=True)
     
-    user_input = st.text_area("Message:", height=100)
-    if st.button("Send 📨") and user_input:
-        process_ai_input(user_input, model_choice)
-    
-    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:
-            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.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.")
+    return content
 
-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 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()
+            with open(uploaded_file.name, 'w', encoding='utf-8') as f:
+                f.write(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 main():
-    st.sidebar.markdown("### 🚲BikeAI🏆 Claude and GPT Multi-Agent Research AI")
+    st.set_page_config(page_title="Markdown Handler", layout="wide")
     
-    # Display file manager in sidebar first
+    # Display file manager in sidebar
     display_file_manager()
     
-    # Model Selection
-    model_choice = st.sidebar.radio(
-        "Choose AI Model:",
-        ["GPT+Claude+Arxiv", "GPT-4o", "Claude-3"]
-    )
+    st.title("📚✨ Super Smart File Handler with Markdown Magic! ✨📚")
     
-    # 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)
+    # Add tabs for different views
+    upload_tab, book_tab = st.tabs(["📤 File Upload", "📖 Book View"])
+    
+    with upload_tab:
+        col1, col2 = st.columns(2)
         
-        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()
+        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"
+            )
+        
+        # Process uploads
+        if single_uploaded_file:
+            content, file_type = read_file_content(single_uploaded_file)
+            if content is not None:
+                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.success(f"🎉 Loaded {uploaded_file.name}")
+            st.rerun()
+        
+        # Show current file if selected
+        if st.session_state.current_file and st.session_state.file_content:
+            st.markdown("---")
+            create_markdown_tabs(st.session_state.file_content, st.session_state.current_file)
+    
+    with book_tab:
+        st.markdown("## 📖 Book View")
+        combined_content = combine_markdown_files()
+        if combined_content:
+            st.markdown(combined_content, unsafe_allow_html=True)
+        else:
+            st.info("Upload some markdown files to see them combined here!")
 
 if __name__ == "__main__":
     main()