Update backup9clonesavenameatlast.app.py

backup9clonesavenameatlast.app.py

@@ -1,25 +1,28 @@
-import streamlit as st
-from azure.cosmos import CosmosClient, exceptions
-import os
-import pandas as pd
-import traceback
-import shutil
-from github import Github
-from git import Repo
-from datetime import datetime
-import base64
-import json
-import uuid
-from urllib.parse import quote
-from gradio_client import Client
+
 import anthropic
+import base64
 import glob
+import hashlib
+import json
+import os
+import pandas as pd
 import pytz
+import random
 import re
-from PIL import Image
-import zipfile
-import hashlib
+import shutil
+import streamlit as st
 import time
+import traceback
+import uuid
+import zipfile
+
+from PIL import Image
+from azure.cosmos import CosmosClient, exceptions
+from datetime import datetime
+from git import Repo
+from github import Github
+from gradio_client import Client
+from urllib.parse import quote
 
 # 🎭 App Configuration - Because every app needs a good costume!
 Site_Name = '🐙Git🌌Cosmos💫 - Azure Cosmos DB and Github Agent'
@@ -70,7 +73,9 @@ def get_download_link(file_path):
 def generate_unique_id():
     timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
     unique_uuid = str(uuid.uuid4())
-    return f"{timestamp}-{unique_uuid}"
+    returnValue = f"{timestamp}-{unique_uuid}"
+    st.write('New Unique ID:' + returnValue)
+    return 
 
 # 📝 Generate a filename - Naming files like a pro (or a very confused librarian)
 def generate_filename(prompt, file_type):
@@ -244,20 +249,19 @@ def push_to_github(local_path, repo, github_token):
     origin.push(refspec=f'{current_branch}:{current_branch}')
 
 
-
-def save_or_clone_to_cosmos_db(container, query=None, response=None, clone_id=None):
+def save_or_clone_to_cosmos_db(container, document=None, clone_id=None):
     def generate_complex_unique_id():
         timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
         random_component = ''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=8))
         return f"{timestamp}-{random_component}-{str(uuid.uuid4())}"
 
     max_retries = 10
-    base_delay = 0.1  # 100 ms
+    base_delay = 0.1
 
     for attempt in range(max_retries):
         try:
             new_id = generate_complex_unique_id()
-
+            
             if clone_id:
                 try:
                     existing_doc = container.read_item(item=clone_id, partition_key=clone_id)
@@ -269,96 +273,30 @@ def save_or_clone_to_cosmos_db(container, query=None, response=None, clone_id=No
                         'cloned_at': datetime.utcnow().isoformat()
                     }
                 except exceptions.CosmosResourceNotFoundError:
-                    st.error(f"Document with ID {clone_id} not found for cloning.")
-                    return None
+                    return False, f"Document with ID {clone_id} not found for cloning."
             else:
-                new_doc = {
-                    'id': new_id,
-                    'query': query,
-                    'response': response,
-                    'created_at': datetime.utcnow().isoformat()
-                }
-
-            # Attempt to create the item
+                if document is None:
+                    return False, "No document provided for saving"
+                
+                document['id'] = new_id
+                document['created_at'] = datetime.utcnow().isoformat()
+                new_doc = document
+
             response = container.create_item(body=new_doc)
-            
-            st.success(f"{'Cloned' if clone_id else 'New'} document saved successfully with ID: {response['id']}")
-            
-            # Refresh the documents in the session state
-            st.session_state.documents = list(container.query_items(
-                query="SELECT * FROM c ORDER BY c._ts DESC",
-                enable_cross_partition_query=True
-            ))
-            
-            return response['id']
+            return True, f"{'Cloned' if clone_id else 'New'} document saved successfully with ID: {response['id']}"
 
         except exceptions.CosmosHttpResponseError as e:
-            if e.status_code == 409:  # Conflict error
+            if e.status_code == 409:
                 delay = base_delay * (2 ** attempt) + random.uniform(0, 0.1)
-                st.warning(f"ID conflict occurred. Retrying in {delay:.2f} seconds... (Attempt {attempt + 1})")
                 time.sleep(delay)
-            else:
-                st.error(f"Error saving to Cosmos DB: {e}")
-                return None
-
+                continue
+            return False, f"Error saving to Cosmos DB: {str(e)}"
         except Exception as e:
-            st.error(f"An unexpected error occurred: {str(e)}")
-            return None
-
-    st.error("Failed to save document after maximum retries.")
-    return None
-
-
+            return False, f"An unexpected error occurred: {str(e)}"
     
-# 💾 Save or clone to Cosmos DB - Because every document deserves a twin
-def save_or_clone_to_cosmos_db2(container, query=None, response=None, clone_id=None):
-    try:
-        if not container:
-            st.error("Cosmos DB container is not initialized.")
-            return
-
-        # Generate a new unique ID
-        new_id = str(uuid.uuid4())
-
-        # Create a new document
-        if clone_id:
-            # If clone_id is provided, we're cloning an existing document
-            try:
-                existing_doc = container.read_item(item=clone_id, partition_key=clone_id)
-                new_doc = existing_doc.copy()
-                new_doc['id'] = new_id
-                new_doc['cloned_from'] = clone_id
-                new_doc['cloned_at'] = datetime.utcnow().isoformat()
-            except exceptions.CosmosResourceNotFoundError:
-                st.error(f"Document with ID {clone_id} not found for cloning.")
-                return
-        else:
-            # If no clone_id, we're creating a new document
-            new_doc = {
-                'id': new_id,
-                'query': query,
-                'response': response,
-                'created_at': datetime.utcnow().isoformat()
-            }
-
-        # Insert the new document
-        container.create_item(body=new_doc)
-
-        st.success(f"{'Cloned' if clone_id else 'New'} document saved successfully with ID: {new_id}")
-
-        # Refresh the documents in the session state
-        st.session_state.documents = list(container.query_items(
-            query="SELECT * FROM c ORDER BY c._ts DESC",
-            enable_cross_partition_query=True
-        ))
-
-        return new_id
-
-    except exceptions.CosmosHttpResponseError as e:
-        st.error(f"Error saving to Cosmos DB: {e}")
-    except Exception as e:
-        st.error(f"An unexpected error occurred: {str(e)}")
+    return False, "Failed to save document after maximum retries."
 
+    
 # 📦 Archive current container - Packing up data like you're moving to a new digital house
 def archive_current_container(database_name, container_name, client):
     try:
@@ -452,11 +390,125 @@ def search_glossary(query):
 
     return result, result2, result3, response2
 
-# 🎭 Main function - Where the magic happens (and occasionally breaks)
+
+
+
+
+# 📝 Generate a safe filename from the first few lines of content
+def generate_filename_from_content(content, file_type="md"):
+    # Extract the first few lines or sentences
+    first_sentence = content.split('\n', 1)[0][:90]  # Limit the length to 90 characters
+    # Remove special characters to make it a valid filename
+    safe_name = re.sub(r'[^\w\s-]', '', first_sentence)
+    # Limit length to be compatible with Windows and Linux
+    safe_name = safe_name[:50].strip()  # Adjust length limit
+    return f"{safe_name}.{file_type}"
+
+# 💾 Create and save a file
+def create_file_from_content(content, should_save=True):
+    if not should_save:
+        return
+    filename = generate_filename_from_content(content)
+    with open(filename, 'w', encoding='utf-8') as file:
+        file.write(content)
+    return filename
+
+# 📂 Display list of saved .md files in the sidebar
+def display_saved_files_in_sidebar():
+    all_files = glob.glob("*.md")
+    all_files.sort(reverse=True)
+    all_files = [file for file in all_files if not file.lower().startswith('readme')]  # Exclude README.md
+
+    st.sidebar.markdown("## 📁 Saved Markdown Files")
+    for file in all_files:
+        col1, col2, col3 = st.sidebar.columns([6, 2, 1])
+        with col1:
+            st.markdown(f"📄 {file}")
+        with col2:
+            st.sidebar.download_button(
+                label="⬇️ Download",
+                data=open(file, 'rb').read(),
+                file_name=file
+            )
+        with col3:
+            if st.sidebar.button("🗑", key=f"delete_{file}"):
+                os.remove(file)
+                st.rerun()
+
+
+def clone_record(container, clone_id):
+    try:
+        existing_doc = container.read_item(item=clone_id, partition_key=clone_id)
+        new_doc = existing_doc.copy()
+        new_doc['id'] = generate_unique_id()  # Generate new unique ID with timestamp
+        new_doc['name'] = new_doc['id']  # Generate new unique ID with timestamp
+        new_doc['createdAt'] = datetime.utcnow().isoformat()  # Update the creation time
+        new_doc['_rid'] = None  # Reset _rid or any system-managed fields
+        new_doc['_self'] = None
+        new_doc['_etag'] = None
+        new_doc['_attachments'] = None
+        new_doc['_ts'] = None  # Reset timestamp to be updated by Cosmos DB automatically
+
+        # Insert the cloned document
+        response = container.create_item(body=new_doc)
+        st.success(f"Cloned document saved successfully with ID: {new_doc['id']} 🎉")
+        
+        # Refresh the documents in session state
+        st.session_state.documents = list(container.query_items(
+            query="SELECT * FROM c ORDER BY c._ts DESC",
+            enable_cross_partition_query=True
+        ))
+
+    except exceptions.CosmosResourceNotFoundError:
+        st.error(f"Document with ID {clone_id} not found for cloning.")
+    except exceptions.CosmosHttpResponseError as e:
+        st.error(f"HTTP error occurred: {str(e)} 🚨")
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {str(e)} 😱")
+
+
+
+
+def create_new_blank_record(container):
+    try:
+        # Get the structure of the latest document (to preserve schema)
+        latest_doc = container.query_items(query="SELECT * FROM c ORDER BY c._ts DESC", enable_cross_partition_query=True, max_item_count=1)
+        if latest_doc:
+            new_doc_structure = latest_doc[0].copy()
+        else:
+            new_doc_structure = {}
+
+        new_doc = {key: "" for key in new_doc_structure.keys()}  # Set all fields to blank
+        new_doc['id'] = generate_unique_id()  # Generate new unique ID
+        new_doc['createdAt'] = datetime.utcnow().isoformat()  # Set creation time
+
+        # Insert the new blank document
+        response = container.create_item(body=new_doc)
+        st.success(f"New blank document saved successfully with ID: {new_doc['id']} 🎉")
+        
+        # Refresh the documents in session state
+        st.session_state.documents = list(container.query_items(
+            query="SELECT * FROM c ORDER BY c._ts DESC",
+            enable_cross_partition_query=True
+        ))
+
+    except exceptions.CosmosHttpResponseError as e:
+        st.error(f"HTTP error occurred: {str(e)} 🚨")
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {str(e)} 😱")
+
+
+
+
+
+                
+# 🎭 Main function - "All the world's a stage, and all the code merely players" -Shakespeare, probably
 def main():
     st.title("🐙Git🌌Cosmos💫 - Azure Cosmos DB and Github Agent")
 
-    # 🚦 Initialize session state
+
+    
+    # 🎲 Session state vars - "Life is like a session state, you never know what you're gonna get"
     if 'logged_in' not in st.session_state:
         st.session_state.logged_in = False
     if 'selected_records' not in st.session_state:
@@ -474,14 +526,32 @@ def main():
     if 'cloned_doc' not in st.session_state:
         st.session_state.cloned_doc = None
 
-    # ⚙️ q= Run ArXiv search from query parameters
+
+    
+    # 🔍 Query processing - "To search or not to search, that is the query" 
     try:
         query_params = st.query_params
         query = query_params.get('q') or query_params.get('query') or ''
         if query:
-            # 🕵️‍♂️ We have a query! Let's process it!
             result, result2, result3, response2 = search_glossary(query)
-            # When saving results, pass the container
+            
+            # 💾 Save results - "Every file you save is a future you pave"
+            try:
+                if st.button("Save AI Output"):
+                    filename = create_file_from_content(result)
+                    st.success(f"File saved: {filename}")                    
+                    filename = create_file_from_content(result2)
+                    st.success(f"File saved: {filename}")
+                    filename = create_file_from_content(result3)
+                    st.success(f"File saved: {filename}")
+                    filename = create_file_from_content(response2)
+                    st.success(f"File saved: {filename}")
+                    
+                display_saved_files_in_sidebar()
+            except Exception as e:
+                st.error(f"An unexpected error occurred: {str(e)} 😱")
+
+            # 🌟 Cosmos DB operations - "In Cosmos DB we trust, but we still handle errors we must"
             try:
                 save_to_cosmos_db(st.session_state.cosmos_container, query, result, result)
                 save_to_cosmos_db(st.session_state.cosmos_container, query, result2, result2)
@@ -493,42 +563,52 @@ def main():
             except Exception as e:
                 st.error(f"An unexpected error occurred: {str(e)} 😱")
 
-            st.stop()  # Stop further execution
+            st.stop()
     except Exception as e:
         st.markdown(' ')
 
-    # 🔐 Automatic Login
+
+    
+    # 🔐 Auth check - "With great keys come great connectivity"
     if Key:
         st.session_state.primary_key = Key
         st.session_state.logged_in = True
     else:
         st.error("Cosmos DB Key is not set in environment variables. 🔑❌")
-        return  # Can't proceed without a key
+        return
+
 
+    
     if st.session_state.logged_in:
-        # 🌌 Initialize Cosmos DB client
+        # 🌌 DB initialization - "In the beginning, there was connection string..."
         try:
             if st.session_state.client is None:
                 st.session_state.client = CosmosClient(ENDPOINT, credential=st.session_state.primary_key)
             
-            # 🗄️ Sidebar for database, container, and document selection
+            # 📚 Navigation setup - "Navigation is not about where you are, but where you're going"
             st.sidebar.title("🐙Git🌌Cosmos💫🗄️Navigator")
             
             databases = get_databases(st.session_state.client)
             selected_db = st.sidebar.selectbox("🗃️ Select Database", databases)
+
+
             
+            # 🔄 State management - "Change is the only constant in state management"
             if selected_db != st.session_state.selected_database:
                 st.session_state.selected_database = selected_db
                 st.session_state.selected_container = None
                 st.session_state.selected_document_id = None
                 st.session_state.current_index = 0
                 st.rerun()
-            
+
+
+                
             if st.session_state.selected_database:
                 database = st.session_state.client.get_database_client(st.session_state.selected_database)
                 containers = get_containers(database)
                 selected_container = st.sidebar.selectbox("📁 Select Container", containers)
                 
+                # 🔄 Container state handling - "Container changes, state arranges"
                 if selected_container != st.session_state.selected_container:
                     st.session_state.selected_container = selected_container
                     st.session_state.selected_document_id = None
@@ -538,37 +618,42 @@ def main():
                 if st.session_state.selected_container:
                     container = database.get_container_client(st.session_state.selected_container)
                     
-                    # 📦 Add Export button
-                    if st.button("📦 Export Container Data"):
-                        download_link = archive_current_container(st.session_state.selected_database, st.session_state.selected_container, st.session_state.client)
+                    # 📦 Export functionality - "Pack it, zip it, ship it"
+                    if st.sidebar.button("📦 Export Container Data"):
+                        download_link = archive_current_container(st.session_state.selected_database, 
+                                                               st.session_state.selected_container, 
+                                                               st.session_state.client)
                         if download_link.startswith('<a'):
                             st.markdown(download_link, unsafe_allow_html=True)
                         else:
                             st.error(download_link)
+
+
                     
-                    # Fetch documents
+                    # 📝 Document handling - "Document, document, on the wall, who's the most recent of them all?"
                     documents = get_documents(container)
                     total_docs = len(documents)
                     
                     if total_docs > 5:
                         documents_to_display = documents[:5]
-                        st.info("Showing top 5 most recent documents.")
+                        st.sidebar.info("Showing top 5 most recent documents.")
                     else:
                         documents_to_display = documents
-                        st.info(f"Showing all {len(documents_to_display)} documents.")
+                        st.sidebar.info(f"Showing all {len(documents_to_display)} documents.")
                     
                     if documents_to_display:
-                        # 🎨 Add Viewer/Editor selection
-                        view_options = ['Show as Markdown', 'Show as Code Editor', 'Show as Edit and Save', 'Clone Document', 'New Record']
-                        selected_view = st.selectbox("Select Viewer/Editor", view_options, index=2)
+                        # 🎨 View options - "Different strokes for different folks"
+                        view_options = ['Show as Markdown', 'Show as Code Editor', 'Show as Edit, Save, Run AI', 'Clone Document', 'New Record']
+                        selected_view = st.sidebar.selectbox("Select Viewer/Editor", view_options, index=2)
                         
                         if selected_view == 'Show as Markdown':
-                            # 🖌️ Show each record as Markdown with navigation
+                            Label = '# 📄 Markdown view - Mark it down, mark it up'
+                            st.markdown(Label)
                             total_docs = len(documents)
                             doc = documents[st.session_state.current_index]
                             st.markdown(f"#### Document ID: {doc.get('id', '')}")
 
-                            # 🕵️‍♂️ Let's extract values from the JSON that have at least one space
+                            # 🕵️ Value extraction - "Finding spaces in all the right places"
                             values_with_space = []
                             def extract_values(obj):
                                 if isinstance(obj, dict):
@@ -582,17 +667,16 @@ def main():
                                         values_with_space.append(obj)
 
                             extract_values(doc)
-
-                            # 🔗 Let's create a list of links for these values
                             st.markdown("#### 🔗 Links for Extracted Texts")
                             for term in values_with_space:
                                 display_glossary_entity(term)
 
-                            # Show the document content as markdown
                             content = json.dumps(doc, indent=2)
                             st.markdown(f"```json\n{content}\n```")
 
-                            # Navigation buttons
+
+                            
+                            # ⬅️➡️ Navigation - "Left and right, day and night"
                             col_prev, col_next = st.columns([1, 1])
                             with col_prev:
                                 if st.button("⬅️ Previous", key='prev_markdown'):
@@ -605,12 +689,22 @@ def main():
                                         st.session_state.current_index += 1
                                         st.rerun()
 
+
+                        
                         elif selected_view == 'Show as Code Editor':
-                            # 💻 Show each record in a code editor with navigation
+                            Label = '# 💻 Code editor view - Code is poetry, bugs are typos'
+                            st.markdown(Label)
                             total_docs = len(documents)
                             doc = documents[st.session_state.current_index]
                             st.markdown(f"#### Document ID: {doc.get('id', '')}")
-                            doc_str = st.text_area("Edit Document", value=json.dumps(doc, indent=2), height=300, key=f'code_editor_{st.session_state.current_index}')
+                            doc_str = st.text_area("Edit Document", 
+                                                 value=json.dumps(doc, indent=2), 
+                                                 height=300, 
+                                                 key=f'code_editor_{st.session_state.current_index}')
+
+
+                            
+                            # ⬅️➡️ Navigation and save controls
                             col_prev, col_next = st.columns([1, 1])
                             with col_prev:
                                 if st.button("⬅️ Previous", key='prev_code'):
@@ -622,6 +716,10 @@ def main():
                                     if st.session_state.current_index < total_docs - 1:
                                         st.session_state.current_index += 1
                                         st.rerun()
+
+
+                            
+                            # 💾 Save functionality - "Save early, save often"
                             if st.button("💾 Save Changes", key=f'save_button_{st.session_state.current_index}'):
                                 try:
                                     updated_doc = json.loads(doc_str)
@@ -634,31 +732,47 @@ def main():
                                         st.error(message)
                                 except json.JSONDecodeError as e:
                                     st.error(f"Invalid JSON: {str(e)} 🚫")
+
+
                                     
-                        elif selected_view == 'Show as Edit and Save':
-                            # ✏️ Show as Edit and Save in columns
+                        elif selected_view == 'Show as Edit, Save, Run AI':
+                            Label = '# ✏️ Edit and save view - Edit with wisdom, save with precision'
+                            st.markdown(Label)
                             st.markdown("#### Edit the document fields below:")
                             
-                            # Create columns for each document
                             num_cols = len(documents_to_display)
                             cols = st.columns(num_cols)
 
+
+                            
                             for idx, (col, doc) in enumerate(zip(cols, documents_to_display)):
                                 with col:
+                                    
                                     st.markdown(f"##### Document ID: {doc.get('id', '')}")
                                     editable_id = st.text_input("ID", value=doc.get('id', ''), key=f'edit_id_{idx}')
-                                    # Remove 'id' from the document for editing other fields
                                     editable_doc = doc.copy()
                                     editable_doc.pop('id', None)
-                                    doc_str = st.text_area("Document Content (in JSON format)", value=json.dumps(editable_doc, indent=2), height=300, key=f'doc_str_{idx}')
+
+                                    st.markdown(f"##### Document Name: {doc.get('name', '')}")
+                                    editable_id = st.text_input("Name", value=doc.get('name', ''), key=f'edit_name_{idx}')
+                                    editable_doc = doc.copy()
+                                    editable_doc.pop('name', None)
+
                                     
-                                    # Add the "Run With AI" button next to "Save Changes"
+                                    doc_str = st.text_area("Document Content (in JSON format)", 
+                                                         value=json.dumps(editable_doc, indent=2), 
+                                                         height=300, 
+                                                         key=f'doc_str_{idx}')
+
+
+                                    
+                                    # 💾🤖 Save and AI operations
                                     col_save, col_ai = st.columns(2)
                                     with col_save:
                                         if st.button("💾 Save Changes", key=f'save_button_{idx}'):
                                             try:
                                                 updated_doc = json.loads(doc_str)
-                                                updated_doc['id'] = editable_id  # Include the possibly edited ID
+                                                updated_doc['id'] = editable_id
                                                 success, message = update_record(container, updated_doc)
                                                 if success:
                                                     st.success(f"Document {updated_doc['id']} saved successfully.")
@@ -668,69 +782,60 @@ def main():
                                                     st.error(message)
                                             except json.JSONDecodeError as e:
                                                 st.error(f"Invalid JSON: {str(e)} 🚫")
+
+                                                
                                     with col_ai:
-                                        if st.button("🤖 Run With AI", key=f'run_with_ai_button_{idx}'):
-                                            # Use the entire document as input
+                                        if st.button("🤖 Run AI", key=f'run_with_ai_button_{idx}'):
                                             search_glossary(json.dumps(editable_doc, indent=2))
-                                            # Usage in your Streamlit app
-                                            if st.button("📄 Clone Document", key=f'clone_button_{idx}'):
-                                                with st.spinner("Cloning document..."):
-                                                    cloned_id = save_or_clone_to_cosmos_db(container, clone_id=doc['id'])
-                                                    if cloned_id:
-                                                        st.success(f"Document cloned successfully with new ID: {cloned_id}")
-                                                        st.rerun()
-                                                    else:
-                                                        st.error("Failed to clone document. Please try again.")
 
+                                            
                         elif selected_view == 'Clone Document':
-                            st.markdown("#### Clone Document:")
+                            st.markdown("#### Clone a document:")
+                            
                             for idx, doc in enumerate(documents_to_display):
-                                st.markdown(f"##### Document ID: {doc.get('id', '')}")
-                                if st.button("📄 Clone Document", key=f'clone_button_{idx}'):
-                                    cloned_doc = doc.copy()
-                                    # Generate new unique IDs
-                                    new_id = str(uuid.uuid4())
-                                    cloned_doc['id'] = new_id
-                                    if 'name' in cloned_doc:
-                                        cloned_doc['name'] = f"{cloned_doc['name']}_clone_{new_id[:8]}"
-                                    st.session_state.cloned_doc = cloned_doc
-                                    st.session_state.cloned_doc_str = json.dumps(cloned_doc, indent=2)
-                                    st.session_state.clone_mode = True
-                                    st.rerun()
-                                        
-                            if st.session_state.get('clone_mode', False):
-                                st.markdown("#### Edit Cloned Document:")
-                                cloned_doc_str = st.text_area(
-                                    "Edit JSON content below:", 
-                                    value=st.session_state.cloned_doc_str, 
-                                    height=300
-                                )
+                                st.markdown(f"##### Original Document ID: {doc.get('id', '')}")
                                 
-                                if st.button("💾 Save Cloned Document"):
-                                    try:
-                                        new_doc = json.loads(cloned_doc_str)
-                                        success, message = insert_record(container, new_doc)
-                                        if success:
-                                            st.success(f"Cloned document saved successfully! 🎉")
-                                            st.session_state.selected_document_id = new_doc['id']
-                                            st.session_state.clone_mode = False
-                                            st.session_state.cloned_doc = None
-                                            st.session_state.cloned_doc_str = ''
-                                            st.rerun()
-                                        else:
-                                            st.error(message)
-                                    except json.JSONDecodeError as e:
-                                        st.error(f"Invalid JSON: {str(e)} 🚫")
-                        
-
-
-                
+                                if st.button("📄 Clone Document", key=f'clone_button_{idx}'):
+                                    # Create new document with unique ID and name
+                                    new_doc = {
+                                        'id': str(uuid.uuid4()),
+                                        'name': f"Clone_{str(uuid.uuid4())[:8]}",
+                                        **{k: v for k, v in doc.items() if k not in ['id', 'name', '_rid', '_self', '_etag', '_attachments', '_ts']}
+                                    }
+                                    
+                                    # Show editable preview
+                                    edited_doc = st.text_area(
+                                        "Edit cloned document:",
+                                        value=json.dumps(new_doc, indent=2),
+                                        height=300,
+                                        key=f'edit_clone_{idx}'
+                                    )
                                     
+                                    if st.button("💾 Save Clone", key=f'save_clone_{idx}'):
+                                        try:
+                                            final_doc = json.loads(edited_doc)
+                                            # Use container.create_item() instead of update_record()
+                                            response = container.create_item(body=final_doc)
+                                            if response:
+                                                st.success(f"New cloned document created with ID: {final_doc['id']}")
+                                                st.rerun()
+                                            else:
+                                                st.error("Failed to create new document")
+                                        except Exception as e:
+                                            st.error(f"Error creating document: {str(e)}")
+                    
+                        #elif selected_view == 'New Record':
                         elif selected_view == 'New Record':
-                            # 🆕 New Record
                             st.markdown("#### Create a new document:")
+                            
                             if st.button("🤖 Insert Auto-Generated Record"):
-                                success, message = save_or_clone_to_cosmos_db(container, query="Auto-generated", response="This is an auto-generated record.")
+                                auto_doc = {
+                                    "id": generate_unique_id(),
+                                    "name": f"Auto-generated Record {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+                                    "content": "This is an auto-generated record.",
+                                    "timestamp": datetime.now().isoformat()
+                                }
+                                success, message = save_or_clone_to_cosmos_db(container, document=auto_doc)
                                 if success:
                                     st.success(message)
                                     st.rerun()
@@ -738,44 +843,59 @@ def main():
                                     st.error(message)
                             else:
                                 new_id = st.text_input("ID", value=generate_unique_id(), key='new_id')
-                                new_doc_str = st.text_area("Document Content (in JSON format)", value='{}', height=300)
+                                default_doc = {
+                                    "id": new_id,
+                                    "name": "New Document",
+                                    "content": "",
+                                    "timestamp": datetime.now().isoformat()
+                                }
+                                new_doc_str = st.text_area("Document Content (in JSON format)", 
+                                                          value=json.dumps(default_doc, indent=2), 
+                                                          height=300)
+                                
                                 if st.button("➕ Create New Document"):
                                     try:
                                         new_doc = json.loads(new_doc_str)
-                                        new_doc['id'] = new_id  # Use the provided ID
+                                        new_doc['id'] = new_id  # Ensure ID matches input field
                                         success, message = insert_record(container, new_doc)
                                         if success:
                                             st.success(f"New document created with id: {new_doc['id']} 🎉")
                                             st.session_state.selected_document_id = new_doc['id']
-                                            # Switch to 'Show as Edit and Save' mode
                                             st.rerun()
                                         else:
                                             st.error(message)
                                     except json.JSONDecodeError as e:
                                         st.error(f"Invalid JSON: {str(e)} 🚫")
+                        
                                     
-                    else:
-                        st.sidebar.info("No documents found in this container. 📭")
-        
-            # 🎉 Main content area
-            st.subheader(f"📊 Container: {st.session_state.selected_container}")
-            if st.session_state.selected_container:
-                if documents_to_display:
-                    df = pd.DataFrame(documents_to_display)
-                    st.dataframe(df)
-                else:
-                    st.info("No documents to display. 🧐")
+                                    st.subheader(f"📊 Container: {st.session_state.selected_container}")
+                                    if st.session_state.selected_container:
+                                        if documents_to_display:
+                                            Label = '# 📊 Data display - Data tells tales that words cannot'
+                                            st.markdown(Label)
+                                            df = pd.DataFrame(documents_to_display)
+                                            st.dataframe(df)
+                                        else:
+                                            st.info("No documents to display. 🧐")
+
+
                 
-            # 🐙 GitHub section
+            Label = '# 🐙 GitHub integration - Git happens'
             st.subheader("🐙 GitHub Operations")
-            github_token = os.environ.get("GITHUB")  # Read GitHub token from environment variable
-            source_repo = st.text_input("Source GitHub Repository URL", value="https://github.com/AaronCWacker/AIExamples-8-24-Streamlit")
-            new_repo_name = st.text_input("New Repository Name (for cloning)", value=f"AIExample-Clone-{datetime.now().strftime('%Y%m%d_%H%M%S')}")
+            github_token = os.environ.get("GITHUB")
+            source_repo = st.text_input("Source GitHub Repository URL", 
+                                      value="https://github.com/AaronCWacker/AIExamples-8-24-Streamlit")
+            new_repo_name = st.text_input("New Repository Name (for cloning)", 
+                                        value=f"AIExample-Clone-{datetime.now().strftime('%Y%m%d_%H%M%S')}")
+
 
+            
             col1, col2 = st.columns(2)
             with col1:
                 if st.button("📥 Clone Repository"):
                     if github_token and source_repo:
+
+                        st.markdown(Label)
                         try:
                             local_path = f"./temp_repo_{datetime.now().strftime('%Y%m%d%H%M%S')}"
                             download_github_repo(source_repo, local_path)
@@ -792,10 +912,14 @@ def main():
                                 os.remove(zip_filename)
                     else:
                         st.error("Please ensure GitHub token is set in environment variables and source repository URL is provided. 🔑❓")
-    
+
+
+            
             with col2:
                 if st.button("📤 Push to New Repository"):
                     if github_token and source_repo:
+
+                        st.markdown(Label)
                         try:
                             g = Github(github_token)
                             new_repo = create_repo(g, new_repo_name)
@@ -811,11 +935,14 @@ def main():
                     else:
                         st.error("Please ensure GitHub token is set in environment variables and source repository URL is provided. 🔑❓")
 
-            # 💬 Chat with Claude
+
+            
             st.subheader("💬 Chat with Claude")
             user_input = st.text_area("Message 📨:", height=100)
 
             if st.button("Send 📨"):
+                Label = '# 💬 Chat functionality - Every chat is a chance to learn'
+                st.markdown(Label)
                 if user_input:
                     response = client.messages.create(
                         model="claude-3-sonnet-20240229",
@@ -835,14 +962,18 @@ def main():
                     # Save to Cosmos DB
                     save_to_cosmos_db(container, user_input, response.content[0].text, "")
 
-            # Display Chat History
+
+            
+            # 📜 Chat history display - "History repeats itself, first as chat, then as wisdom"
             st.subheader("Past Conversations 📜")
             for chat in st.session_state.chat_history:
                 st.text_area("You said 💬:", chat["user"], height=100, disabled=True)
                 st.text_area("Claude replied 🤖:", chat["claude"], height=200, disabled=True)
                 st.markdown("---")
 
-            # File Editor
+
+            
+            # 📝 File editor - "Edit with care, save with flair"
             if hasattr(st.session_state, 'current_file'):
                 st.subheader(f"Editing: {st.session_state.current_file} 🛠")
                 new_content = st.text_area("File Content ✏️:", st.session_state.file_content, height=300)
@@ -851,7 +982,9 @@ def main():
                         file.write(new_content)
                     st.success("File updated successfully! 🎉")
 
-            # File Management
+
+            
+            # 📂 File management - "Manage many, maintain order"
             st.sidebar.title("📁 File Management")
             
             all_files = glob.glob("*.md")
@@ -883,13 +1016,18 @@ def main():
                         os.remove(file)
                         st.rerun()
 
+                        
+
         except exceptions.CosmosHttpResponseError as e:
             st.error(f"Failed to connect to Cosmos DB. HTTP error: {str(e)} 🚨")
         except Exception as e:
             st.error(f"An unexpected error occurred: {str(e)} 😱")
 
-    # 🚪 Logout button
+
+    
     if st.session_state.logged_in and st.sidebar.button("🚪 Logout"):
+        Label = '# 🚪 Logout - All good things must come to an end'
+        st.markdown(Label)
         st.session_state.logged_in = False
         st.session_state.selected_records.clear()
         st.session_state.client = None