Update app.py

app.py

@@ -1,4 +1,7 @@
-# 📚📚📚 IMPORTS 📚📚📚
+ app.py
+# =============================================================================
+# ───────────── IMPORTS ─────────────
+# =============================================================================
 import base64
 import glob
 import hashlib
@@ -26,7 +29,9 @@ import requests
 import numpy as np
 from urllib.parse import quote
 
-# 🌐🌐🌐 EXTERNAL HELP LINKS (Always visible in sidebar) 🌐🌐🌐
+# =============================================================================
+# ───────────── EXTERNAL HELP LINKS (Always visible in sidebar) ─────────────
+# =============================================================================
 external_links = [
     {"title": "CosmosDB GenAI Full Text Search", "url": "https://learn.microsoft.com/en-us/azure/cosmos-db/gen-ai/full-text-search", "emoji": "💻"},
     {"title": "CosmosDB SQL API Client Library", "url": "https://learn.microsoft.com/en-us/python/api/overview/azure/cosmos-readme?view=azure-python", "emoji": "💻"},
@@ -41,7 +46,9 @@ external_links = [
     {"title": "arcee.ai Official Website", "url": "https://arcee.ai", "emoji": "🌐"},
 ]
 
-# 🚀🚀🚀 APP CONFIGURATION 🚀🚀🚀
+# =============================================================================
+# ───────────── APP CONFIGURATION ─────────────
+# =============================================================================
 Site_Name = '🐙 GitCosmos'
 title = "🐙 GitCosmos"
 helpURL = 'https://huggingface.co/awacke1'
@@ -59,7 +66,7 @@ st.set_page_config(
     }
 )
 
-# 🌌🌌🌌 COSMOS DB & APP CONFIGURATION 🌌🌌🌌
+# Cosmos DB & App URLs
 ENDPOINT = "https://acae-afd.documents.azure.com:443/"
 DATABASE_NAME = os.environ.get("COSMOS_DATABASE_NAME")
 CONTAINER_NAME = os.environ.get("COSMOS_CONTAINER_NAME")
@@ -67,7 +74,9 @@ Key = os.environ.get("Key")
 LOCAL_APP_URL = "https://huggingface.co/spaces/awacke1/AzureCosmosDBUI"
 CosmosDBUrl = 'https://portal.azure.com/#@AaronCWackergmail.onmicrosoft.com/resource/subscriptions/003fba60-5b3f-48f4-ab36-3ed11bc40816/resourceGroups/datasets/providers/Microsoft.DocumentDB/databaseAccounts/acae-afd/dataExplorer'
 
-# 🔧🔧🔧 HELPER FUNCTIONS 🔧🔧🔧
+# =============================================================================
+# ───────────── HELPER FUNCTIONS ─────────────
+# =============================================================================
 def get_download_link(file_path):
     with open(file_path, "rb") as file:
         contents = file.read()
@@ -141,12 +150,17 @@ def preprocess_text(text):
     text = re.sub(r'[^\x00-\x7F]+', '', text)
     return text.strip()
 
+# NEW: Sanitize JSON text before saving (remove problematic control characters)
 def sanitize_json_text(text):
+    # Remove control characters except newline, carriage return, and tab
     text = re.sub(r'[\x00-\x08\x0B\x0C\x0E-\x1F]', '', text)
+    # Escape newline, tab, and carriage return
     text = text.replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t")
     return text
 
-# 🌌🌌🌌 COSMOS DB FUNCTIONS 🌌🌌🌌
+# =============================================================================
+# ───────────── COSMOS DB FUNCTIONS ─────────────
+# =============================================================================
 def get_databases(client):
     return [db['id'] for db in client.list_databases()]
 
@@ -181,15 +195,52 @@ def delete_record(container, record):
         if "id" not in record:
             return False, "Record must contain an 'id' field. 🛑"
         doc_id = record["id"]
+        if "delete_log" not in st.session_state:
+            st.session_state.delete_log = []
+        st.session_state.delete_log.append(f"Attempting to delete document: {json.dumps(record, indent=2)}")
         partition_key_value = record.get("pk", doc_id)
+        st.session_state.delete_log.append(f"Using ID and Partition Key: {partition_key_value}")
         container.delete_item(item=doc_id, partition_key=partition_key_value)
-        return True, f"Record {doc_id} successfully deleted from Cosmos DB. 🗑️"
+        success_msg = f"Record {doc_id} successfully deleted from Cosmos DB. 🗑️"
+        st.session_state.delete_log.append(success_msg)
+        return True, success_msg
     except exceptions.CosmosResourceNotFoundError:
-        return True, f"Record {doc_id} not found in Cosmos DB (already deleted or never existed). 🗑️"
+        success_msg = f"Record {doc_id} not found in Cosmos DB (already deleted or never existed). 🗑️"
+        st.session_state.delete_log.append(success_msg)
+        return True, success_msg
     except exceptions.CosmosHttpResponseError as e:
-        return False, f"HTTP error deleting {doc_id}: {str(e)}. 🚨"
+        error_msg = f"HTTP error deleting {doc_id}: {str(e)}. 🚨"
+        st.session_state.delete_log.append(error_msg)
+        return False, error_msg
     except Exception as e:
-        return False, f"Unexpected error deleting {doc_id}: {str(traceback.format_exc())}. 😱"
+        error_msg = f"Unexpected error deleting {doc_id}: {str(traceback.format_exc())}. 😱"
+        st.session_state.delete_log.append(error_msg)
+        return False, error_msg
+
+def save_to_cosmos_db(container, query, response1, response2):
+    try:
+        if container:
+            timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
+            unique_uuid = str(uuid.uuid4())
+            new_id = f"{timestamp}-{unique_uuid}"
+            record = {
+                "id": new_id,
+                "pk": new_id,
+                "name": new_id,
+                "query": query,
+                "response1": response1,
+                "response2": response2,
+                "timestamp": datetime.utcnow().isoformat(),
+                "type": "ai_response",
+                "version": "1.0"
+            }
+            container.create_item(body=record)
+            st.success(f"Saved: {record['id']}")
+            st.session_state.documents = get_documents(container)
+        else:
+            st.error("Cosmos container not initialized.")
+    except Exception as e:
+        st.error(f"Save error: {str(e)}")
 
 def archive_current_container(database_name, container_name, client):
     try:
@@ -212,273 +263,111 @@ def archive_current_container(database_name, container_name, client):
     except Exception as e:
         return f"Archive error: {str(e)} 😢"
 
-# 🌠🌠🌠 ADVANCED COSMOS FUNCTIONS (if needed) 🌠🌠🌠
-# (Include your advanced Cosmos functions here if needed)
-# For example, you might have functions like create_new_container(), etc.
-
-# 🎉🎉🎉 NEW COSMOSDB DEMO FUNCTIONS (Using ENDPOINT and Key) 🎉🎉🎉
-def demo_create_database():
-    st.markdown("### Demo: Create Database")
-    database_name = st.text_input("Enter Database Name", value="testDatabase", key="demo_db_name")
-    if st.button("Create Database", key="btn_create_db"):
-        if not ENDPOINT or not Key:
-            st.error("Missing Cosmos configuration: ENDPOINT or Key")
-            return
-        client_demo = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = client_demo.create_database(database_name)
-            st.success(f"Database '{database_name}' created.")
-            st.write(database)
-        except exceptions.CosmosResourceExistsError:
-            database = client_demo.get_database_client(database_name)
-            st.info(f"Database '{database_name}' already exists.")
-            st.write(database)
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
-
-def demo_create_container():
-    st.markdown("### Demo: Create Container")
-    database_name = st.text_input("Enter Database Name", value="testDatabase", key="demo_db_for_container")
-    container_name = st.text_input("Enter Container Name", value="products", key="demo_container_name")
-    partition_key = st.text_input("Enter Partition Key Path", value="/productName", key="demo_partition_key")
-    if st.button("Create Container", key="btn_create_container"):
-        if not ENDPOINT or not Key:
-            st.error("Missing Cosmos configuration: ENDPOINT or Key")
-            return
-        client_demo = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = client_demo.get_database_client(database_name)
-            container = database.create_container(id=container_name, partition_key=PartitionKey(path=partition_key))
-            st.success(f"Container '{container_name}' created.")
-            st.write(container)
-        except exceptions.CosmosResourceExistsError:
-            container = database.get_container_client(container_name)
-            st.info(f"Container '{container_name}' already exists.")
-            st.write(container)
-        except exceptions.CosmosHttpResponseError as e:
-            st.error(f"HTTP error: {str(e)}")
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
-
-def demo_create_analytical_container():
-    st.markdown("### Demo: Create Analytical Store Enabled Container")
-    database_name = st.text_input("Enter Database Name", value="testDatabase", key="demo_db_for_analytical")
-    container_name = st.text_input("Enter Container Name", value="products", key="demo_container_analytical")
-    partition_key = st.text_input("Enter Partition Key Path", value="/productName", key="demo_partition_key_analytical")
-    if st.button("Create Analytical Container", key="btn_create_analytical"):
-        if not ENDPOINT or not Key:
-            st.error("Missing Cosmos configuration: ENDPOINT or Key")
-            return
-        client_demo = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = client_demo.get_database_client(database_name)
+# =============================================================================
+# ───────────── ADVANCED COSMOS FUNCTIONS ─────────────
+# =============================================================================
+def create_new_container(database, container_id, partition_key_path,
+                         analytical_storage_ttl=None, indexing_policy=None, vector_embedding_policy=None):
+    try:
+        if analytical_storage_ttl is not None:
             container = database.create_container(
-                id=container_name, 
-                partition_key=PartitionKey(path=partition_key),
-                analytical_storage_ttl=-1
+                id=container_id,
+                partition_key=PartitionKey(path=partition_key_path),
+                analytical_storage_ttl=analytical_storage_ttl,
+                indexing_policy=indexing_policy,
+                vector_embedding_policy=vector_embedding_policy
             )
-            st.success(f"Analytical container '{container_name}' created.")
-            st.write(container)
-        except exceptions.CosmosResourceExistsError:
-            container = database.get_container_client(container_name)
-            st.info(f"Container '{container_name}' already exists.")
-            st.write(container)
-        except exceptions.CosmosHttpResponseError as e:
-            st.error(f"HTTP error: {str(e)}")
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
-
-def demo_get_existing_container():
-    st.markdown("### Demo: Get Existing Container")
-    database_name = st.text_input("Enter Database Name", value="testDatabase", key="demo_db_get")
-    container_name = st.text_input("Enter Container Name", value="products", key="demo_container_get")
-    if st.button("Get Container", key="btn_get_container"):
-        if not ENDPOINT or not Key:
-            st.error("Missing Cosmos configuration: ENDPOINT or Key")
-            return
-        client_demo = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = client_demo.get_database_client(database_name)
-            container = database.get_container_client(container_name)
-            st.success(f"Retrieved container '{container_name}'.")
-            st.write(container)
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
+        else:
+            container = database.create_container(
+                id=container_id,
+                partition_key=PartitionKey(path=partition_key_path),
+                indexing_policy=indexing_policy,
+                vector_embedding_policy=vector_embedding_policy
+            )
+    except exceptions.CosmosHttpResponseError as e:
+        if analytical_storage_ttl is not None and "analyticalStorageTtl" in str(e):
+            try:
+                container = database.create_container(
+                    id=container_id,
+                    partition_key=PartitionKey(path=partition_key_path),
+                    indexing_policy=indexing_policy,
+                    vector_embedding_policy=vector_embedding_policy
+                )
+            except Exception as e2:
+                st.error(f"Error creating container without analytical_storage_ttl: {str(e2)}")
+                return None
+        elif isinstance(e, exceptions.CosmosResourceExistsError):
+            container = database.get_container_client(container_id)
+        else:
+            st.error(f"Error creating container: {str(e)}")
+            return None
+    return container
 
-def demo_insert_data():
-    st.markdown("### Demo: Insert Data")
-    database_name = st.text_input("Enter Database Name", value="testDatabase", key="demo_db_insert")
-    container_name = st.text_input("Enter Container Name", value="products", key="demo_container_insert")
-    num_items = st.number_input("Number of items to insert", min_value=1, max_value=20, value=9, key="demo_num_items")
-    if st.button("Insert Data", key="btn_insert_data"):
-        if not ENDPOINT or not Key:
-            st.error("Missing Cosmos configuration: ENDPOINT or Key")
-            return
-        client_demo = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = client_demo.get_database_client(database_name)
-            container = database.get_container_client(container_name)
-            for i in range(1, int(num_items) + 1):
-                container.upsert_item({
-                    'id': f'item{i}',
-                    'productName': 'Widget',
-                    'productModel': f'Model {i}'
-                })
-            st.success(f"Inserted {num_items} items.")
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
+def advanced_insert_item(container, item):
+    try:
+        container.upsert_item(item)
+        return True, f"Item {item.get('id', '')} inserted. ➕"
+    except Exception as e:
+        return False, str(e)
 
-def demo_delete_data():
-    st.markdown("### Demo: Delete Data")
-    database_name = st.text_input("Enter Database Name", value="testDatabase", key="demo_db_delete")
-    container_name = st.text_input("Enter Container Name", value="products", key="demo_container_delete")
-    query_model = st.text_input("Product Model to delete", value="Model 2", key="demo_query_model")
-    if st.button("Delete Data", key="btn_delete_data"):
-        if not ENDPOINT or not Key:
-            st.error("Missing Cosmos configuration: ENDPOINT or Key")
-            return
-        client_demo = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = client_demo.get_database_client(database_name)
-            container = database.get_container_client(container_name)
-            items = list(container.query_items(
-                query=f'SELECT * FROM products p WHERE p.productModel = "{query_model}"',
-                enable_cross_partition_query=True
-            ))
-            count = 0
-            for item in items:
-                container.delete_item(item, partition_key=item.get("productName", "Widget"))
-                count += 1
-            st.success(f"Deleted {count} items with productModel = '{query_model}'.")
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
+def advanced_update_item(container, item):
+    try:
+        container.upsert_item(item)
+        return True, f"Item {item.get('id', '')} updated. ✏️"
+    except Exception as e:
+        return False, str(e)
 
-def demo_query_database():
-    st.markdown("### Demo: Query Database")
-    database_name = st.text_input("Enter Database Name", value="testDatabase", key="demo_db_query")
-    container_name = st.text_input("Enter Container Name", value="products", key="demo_container_query")
-    query_str = st.text_area("Enter SQL Query", value='SELECT * FROM mycontainer r WHERE r.id="item3"', key="demo_query_str")
-    if st.button("Run Query", key="btn_query_database"):
-        if not ENDPOINT or not Key:
-            st.error("Missing Cosmos configuration: ENDPOINT or Key")
-            return
-        client_demo = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = client_demo.get_database_client(database_name)
-            container = database.get_container_client(container_name)
-            results = list(container.query_items(query=query_str, enable_cross_partition_query=True))
-            if results:
-                for item in results:
-                    st.json(item)
-            else:
-                st.info("No results found.")
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
+def advanced_delete_item(container, item_id, partition_key_value):
+    try:
+        container.delete_item(item=item_id, partition_key=partition_key_value)
+        return True, f"Item {item_id} deleted. 🗑️"
+    except Exception as e:
+        return False, str(e)
 
-def demo_parameterized_query():
-    st.markdown("### Demo: Parameterized Query")
-    database_name = st.text_input("Enter Database Name", value="testDatabase", key="demo_db_param")
-    container_name = st.text_input("Enter Container Name", value="products", key="demo_container_param")
-    model_value = st.text_input("Enter productModel value", value="Model 7", key="demo_model_value")
-    if st.button("Run Parameterized Query", key="btn_param_query"):
-        if not ENDPOINT or not Key:
-            st.error("Missing Cosmos configuration: ENDPOINT or Key")
-            return
-        client_demo = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = client_demo.get_database_client(database_name)
-            container = database.get_container_client(container_name)
-            discontinued_items = container.query_items(
-                query='SELECT * FROM products p WHERE p.productModel = @model',
-                parameters=[{"name": "@model", "value": model_value}],
-                enable_cross_partition_query=True
-            )
-            for item in discontinued_items:
-                st.json(item)
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
+def vector_search(container, query_vector, vector_field, top=10, exact_search=False):
+    query_vector_str = json.dumps(query_vector)
+    query = f"""SELECT TOP {top} c.id, VectorDistance(c.{vector_field}, {query_vector_str}, {str(exact_search).lower()}, 
+    {{'dataType':'float32','distanceFunction':'cosine'}}) AS SimilarityScore 
+    FROM c ORDER BY SimilarityScore"""
+    results = list(container.query_items(query=query, enable_cross_partition_query=True))
+    return results
 
-def demo_get_db_properties():
-    st.markdown("### Demo: Get Database Properties")
-    database_name = st.text_input("Enter Database Name", value="testDatabase", key="demo_db_props")
-    if st.button("Get Properties", key="btn_db_props"):
-        if not ENDPOINT or not Key:
-            st.error("Missing Cosmos configuration: ENDPOINT or Key")
-            return
-        client_demo = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = client_demo.get_database_client(database_name)
-            props = database.read()
-            st.json(props)
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
+# =============================================================================
+# ───────────── GITHUB FUNCTIONS ─────────────
+# =============================================================================
+def download_github_repo(url, local_path):
+    if os.path.exists(local_path):
+        shutil.rmtree(local_path)
+    Repo.clone_from(url, local_path)
 
-def demo_get_throughput():
-    st.markdown("### Demo: Get Throughput (Database & Container)")
-    database_name = st.text_input("Enter Database Name", value="testDatabase", key="demo_db_throughput")
-    container_name = st.text_input("Enter Container Name (for container throughput)", value="testContainer", key="demo_container_throughput")
-    if st.button("Get Throughput", key="btn_get_throughput"):
-        if not ENDPOINT or not Key:
-            st.error("Missing Cosmos configuration: ENDPOINT or Key")
-            return
-        client_demo = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = client_demo.get_database_client(database_name)
-            db_offer = database.get_throughput()
-            st.write(f"Database Offer: {db_offer.properties['id']} with throughput {db_offer.properties['content']['offerThroughput']}")
-            try:
-                container = database.get_container_client(container_name)
-                container_offer = container.get_throughput()
-                st.write(f"Container Offer: {container_offer.properties['id']} with throughput {container_offer.properties['content']['offerThroughput']}")
-            except exceptions.CosmosHttpResponseError as e:
-                st.error(f"Container throughput error: {str(e)}")
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
+def create_zip_file(source_dir, output_filename):
+    shutil.make_archive(output_filename, 'zip', source_dir)
 
-def demo_modify_container_properties():
-    st.markdown("### Demo: Modify Container Properties (Set default TTL)")
-    database_name = st.text_input("Enter Database Name", value="testDatabase", key="demo_db_modify")
-    container_name = st.text_input("Enter Container Name", value="products", key="demo_container_modify")
-    new_ttl = st.number_input("Enter new default TTL (seconds)", min_value=0, value=10, key="demo_new_ttl")
-    if st.button("Modify Container", key="btn_modify_container"):
-        if not ENDPOINT or not Key:
-            st.error("Missing Cosmos configuration: ENDPOINT or Key")
-            return
-        client_demo = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = client_demo.get_database_client(database_name)
-            container = database.get_container_client(container_name)
-            # Using replace_container as in your snippet.
-            database.replace_container(
-                container,
-                partition_key=PartitionKey(path="/productName"),
-                default_ttl=new_ttl,
-            )
-            container_props = container.read()
-            st.write("New default TTL:", container_props.get("defaultTtl"))
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
+def create_repo(g, repo_name):
+    user = g.get_user()
+    return user.create_repo(repo_name)
 
-def demo_item_response_headers():
-    st.markdown("### Demo: Using Item Point Operation Response Headers")
-    database_name = st.text_input("Enter Database Name", value="testDatabase", key="demo_db_headers")
-    container_name = st.text_input("Enter Container Name", value="products", key="demo_container_headers")
-    if st.button("Create Item & Show Headers", key="btn_item_headers"):
-        if not ENDPOINT or not Key:
-            st.error("Missing Cosmos configuration: ENDPOINT or Key")
-            return
-        client_demo = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = client_demo.get_database_client(database_name)
-            container = database.get_container_client(container_name)
-            operation_response = container.create_item({"id": "test_item", "productName": "test_item"})
-            headers = operation_response.get_response_headers()
-            st.write("ETag:", headers.get("etag"))
-            st.write("Request Charge:", headers.get("x-ms-request-charge"))
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
+def push_to_github(local_path, repo, github_token):
+    repo_url = f"https://{github_token}@github.com/{repo.full_name}.git"
+    local_repo = Repo(local_path)
+    if 'origin' in [remote.name for remote in local_repo.remotes]:
+        origin = local_repo.remote('origin')
+        origin.set_url(repo_url)
+    else:
+        origin = local_repo.create_remote('origin', repo_url)
+    if not local_repo.heads:
+        local_repo.git.checkout('-b', 'main')
+        current_branch = 'main'
+    else:
+        current_branch = local_repo.active_branch.name
+    local_repo.git.add(A=True)
+    if local_repo.is_dirty():
+        local_repo.git.commit('-m', 'Initial commit')
+    origin.push(refspec=f'{current_branch}:{current_branch}')
 
-# 📁📁📁 FILE & MEDIA MANAGEMENT FUNCTIONS 📁📁📁
+# =============================================================================
+# ───────────── FILE & MEDIA MANAGEMENT FUNCTIONS ─────────────
+# =============================================================================
 def display_saved_files_in_sidebar():
     all_files = sorted([f for f in glob.glob("*.md") if not f.lower().startswith('readme')], reverse=True)
     st.sidebar.markdown("## 📁 Files")
@@ -523,7 +412,7 @@ def display_file_editor(file_path):
     with md_tab:
         st.markdown(st.session_state.file_content[file_path])
     with code_tab:
-        new_content = st.text_area("Edit:", value=st.session_state.file_content[file_path], height=400, key=f"editor_{hash(file_path)}", on_change=lambda: None)
+        new_content = st.text_area("Edit:", value=st.session_state.file_content[file_path], height=400, key=f"editor_{hash(file_path)}", on_change=lambda: auto_save_edit())
     col1, col2 = st.columns([1, 5])
     with col1:
         if st.button("💾 Save"):
@@ -610,7 +499,9 @@ def update_file_management_section():
         elif st.session_state.file_view_mode == 'edit':
             display_file_editor(st.session_state.current_file)
 
-# 📊📊📊 SIDEBAR DATA GRID (Records with formatted timestamps) 📊📊📊
+# =============================================================================
+# ───────────── SIDEBAR DATA GRID (Records with formatted timestamps) ─────────────
+# =============================================================================
 def show_sidebar_data_grid():
     if st.session_state.get("current_container"):
         try:
@@ -636,7 +527,29 @@ def show_sidebar_data_grid():
     else:
         st.sidebar.info("No container selected for data grid.")
 
-# 📝📝📝 DOCUMENTS LIST VIEW (Editable List with Sorting) 📝📝📝
+# =============================================================================
+# ───────────── SEARCH RESULTS DISPLAY (Editable Code Editors)
+# =============================================================================
+def display_search_results(keyword, container):
+    results = vector_keyword_search(keyword, container)
+    st.markdown("### 🔍 Search Results")
+    for res in results:
+        doc_id = res.get("id", "")
+        exp = st.expander(f"Result {doc_id}")
+        with exp:
+            edited = st.text_area("Edit Document", value=json.dumps(res, indent=2), key=f"search_{doc_id}")
+            if st.button(f"💾 Save changes for {doc_id}", key=f"save_search_{doc_id}"):
+                try:
+                    updated_doc = json.loads(edited)
+                    container.upsert_item(body=updated_doc)
+                    st.success(f"Updated {doc_id}!")
+                    st.experimental_rerun()
+                except Exception as e:
+                    st.error(f"Error saving {doc_id}: {str(e)}")
+
+# =============================================================================
+# ───────────── DOCUMENTS LIST VIEW (Editable List with Sorting)
+# =============================================================================
 def edit_documents_list(container):
     records = get_documents(container)
     sort_option = st.selectbox("Sort by", ["Timestamp", "Name"], key="sort_option")
@@ -674,9 +587,11 @@ def edit_documents_list(container):
                         st.success(f"Updated {doc_id} 👍")
                     else:
                         st.error(f"Error updating {doc_id}: {message}")
-        st.rerun()
+        st.experimental_rerun()
 
-# 🎥🎵🎥 VIDEO & AUDIO UI FUNCTIONS 🎥🎵🎥
+# =============================================================================
+# ───────────── VIDEO & AUDIO UI FUNCTIONS ─────────────
+# =============================================================================
 def validate_and_preprocess_image(file_data, target_size=(576, 1024)):
     try:
         st.write("Preprocessing image...")
@@ -790,7 +705,9 @@ def add_video_generation_ui(container):
         except Exception as e:
             st.error(f"Upload error: {str(e)}")
 
-# ➕➕➕ NEW ITEM & FIELD FUNCTIONS ➕➕➕
+# =============================================================================
+# ───────────── NEW ITEM & FIELD FUNCTIONS
+# =============================================================================
 def new_item_default(container):
     new_id = generate_unique_id()
     default_doc = {
@@ -835,7 +752,9 @@ def add_field_to_doc():
     except Exception as e:
          st.error(f"Error adding field: {str(e)}")
 
-# 🔍🔍🔍 VECTOR SEARCH INTERFACE 🔍🔍🔍
+# =============================================================================
+# ───────────── VECTOR SEARCH INTERFACE (Simple keyword search)
+# =============================================================================
 def vector_keyword_search(keyword, container):
     try:
         query = f"SELECT * FROM c WHERE CONTAINS(c.content, '{keyword}')"
@@ -845,24 +764,9 @@ def vector_keyword_search(keyword, container):
         st.error(f"Vector search error: {str(e)}")
         return []
 
-def display_search_results(keyword, container):
-    results = vector_keyword_search(keyword, container)
-    st.markdown("### 🔍 Search Results")
-    for res in results:
-        doc_id = res.get("id", "")
-        exp = st.expander(f"Result {doc_id}")
-        with exp:
-            edited = st.text_area("Edit Document", value=json.dumps(res, indent=2), key=f"search_{doc_id}")
-            if st.button(f"💾 Save changes for {doc_id}", key=f"save_search_{doc_id}"):
-                try:
-                    updated_doc = json.loads(edited)
-                    container.upsert_item(body=updated_doc)
-                    st.success(f"Updated {doc_id}!")
-                    st.rerun()
-                except Exception as e:
-                    st.error(f"Error saving {doc_id}: {str(e)}")
-
-# 🤖🤖🤖 NEW AI MODALITY RECORD TEMPLATES 🤖🤖🤖
+# =============================================================================
+# ───────────── NEW AI MODALITY RECORD TEMPLATES
+# =============================================================================
 def new_ai_record(container):
     new_id = generate_unique_id()
     default_doc = {
@@ -904,7 +808,9 @@ def new_links_record(container):
          st.error("Error creating links record: " + message)
          return None
 
-# 🏷️🏷️🏷️ SIDEBAR DATA GRID (Editable Names Grid) 🏷️🏷️🏷️
+# =============================================================================
+# ───────────── SIDEBAR DATA GRID (Editable Names Grid)
+# =============================================================================
 def edit_names_grid(container):
     records = get_documents(container)
     data = []
@@ -935,9 +841,298 @@ def edit_names_grid(container):
                         st.sidebar.success(f"Updated Name for {doc_id} to '{row['Name']}'")
                     else:
                         st.sidebar.error(f"Update error for {doc_id}: {message}")
-        st.rerun()
+        st.experimental_rerun()
+
+# =============================================================================
+# ───────────── SEARCH RESULTS DISPLAY (Editable Code Editors)
+# =============================================================================
+def display_search_results(keyword, container):
+    results = vector_keyword_search(keyword, container)
+    st.markdown("### 🔍 Search Results")
+    for res in results:
+        doc_id = res.get("id", "")
+        exp = st.expander(f"Result {doc_id}")
+        with exp:
+            edited = st.text_area("Edit Document", value=json.dumps(res, indent=2), key=f"search_{doc_id}")
+            if st.button(f"💾 Save changes for {doc_id}", key=f"save_search_{doc_id}"):
+                try:
+                    updated_doc = json.loads(edited)
+                    container.upsert_item(body=updated_doc)
+                    st.success(f"Updated {doc_id}!")
+                    st.experimental_rerun()
+                except Exception as e:
+                    st.error(f"Error saving {doc_id}: {str(e)}")
+
+# =============================================================================
+# ───────────── DOCUMENTS LIST VIEW (Editable List with Sorting)
+# =============================================================================
+def edit_documents_list(container):
+    records = get_documents(container)
+    sort_option = st.selectbox("Sort by", ["Timestamp", "Name"], key="sort_option")
+    if sort_option == "Name":
+        records.sort(key=lambda r: r.get("name", "").lower())
+    else:
+        records.sort(key=lambda r: r.get("timestamp", ""), reverse=True)
+    data = []
+    for rec in records:
+        ts = rec.get("timestamp", "")
+        try:
+            dt = datetime.fromisoformat(ts)
+            formatted = dt.strftime("%I:%M %p %m/%d/%Y")
+        except Exception:
+            formatted = ts
+        data.append({
+            "ID": rec.get("id", ""),
+            "Name": rec.get("name", ""),
+            "Content": rec.get("content", "")[:100] + "..." if rec.get("content", "") else "",
+            "Timestamp": formatted
+        })
+    df = pd.DataFrame(data)
+    edited_df = st.data_editor(df[["Name", "Content", "Timestamp"]], key="docs_editor", num_rows="dynamic")
+    if st.button("💾 Save List Changes"):
+        for idx, row in edited_df.iterrows():
+            original = data[idx]
+            if row["Name"] != original["Name"] or row["Content"] != original["Content"]:
+                doc_id = original["ID"]
+                doc = next((r for r in records if r.get("id") == doc_id), None)
+                if doc:
+                    doc["name"] = row["Name"]
+                    doc["content"] = row["Content"]
+                    success, message = update_record(container, doc)
+                    if success:
+                        st.success(f"Updated {doc_id} 👍")
+                    else:
+                        st.error(f"Error updating {doc_id}: {message}")
+        st.experimental_rerun()
 
-# 🔎🔎🔎 SEARCH DOCUMENTS UI 🔎🔎🔎
+# =============================================================================
+# ───────────── VIDEO & AUDIO UI FUNCTIONS ─────────────
+# =============================================================================
+def validate_and_preprocess_image(file_data, target_size=(576, 1024)):
+    try:
+        st.write("Preprocessing image...")
+        if isinstance(file_data, bytes):
+            img = Image.open(io.BytesIO(file_data))
+        elif hasattr(file_data, 'read'):
+            if hasattr(file_data, 'seek'):
+                file_data.seek(0)
+            img = Image.open(file_data)
+        elif isinstance(file_data, Image.Image):
+            img = file_data
+        else:
+            raise ValueError(f"Unsupported input: {type(file_data)}")
+        if img.mode != 'RGB':
+            img = img.convert('RGB')
+        aspect_ratio = img.size[0] / img.size[1]
+        if aspect_ratio > target_size[0] / target_size[1]:
+            new_width = target_size[0]
+            new_height = int(new_width / aspect_ratio)
+        else:
+            new_height = target_size[1]
+            new_width = int(new_height * aspect_ratio)
+        new_width = (new_width // 2) * 2
+        new_height = (new_height // 2) * 2
+        resized_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        final_img = Image.new('RGB', target_size, (255, 255, 255))
+        paste_x = (target_size[0] - new_width) // 2
+        paste_y = (target_size[1] - new_height) // 2
+        final_img.paste(resized_img, (paste_x, paste_y))
+        return final_img
+    except Exception as e:
+        st.error(f"Image error: {str(e)}")
+        return None
+
+def add_video_generation_ui(container):
+    st.markdown("### 🎥 Video Gen")
+    col1, col2 = st.columns([2, 1])
+    with col1:
+        uploaded_file = st.file_uploader("Upload Image 🖼️", type=['png', 'jpg', 'jpeg'])
+    with col2:
+        st.markdown("#### Params")
+        motion = st.slider("🌊 Motion", 1, 255, 127)
+        fps = st.slider("🎬 FPS", 1, 30, 6)
+        with st.expander("Advanced"):
+            use_custom = st.checkbox("Custom Seed")
+            seed = st.number_input("Seed", value=int(time.time() * 1000)) if use_custom else None
+    if uploaded_file is not None:
+        try:
+            file_data = uploaded_file.read()
+            preview1, preview2 = st.columns(2)
+            with preview1:
+                st.write("Original")
+                st.image(Image.open(io.BytesIO(file_data)), use_column_width=True)
+            with preview2:
+                proc_img = validate_and_preprocess_image(io.BytesIO(file_data))
+                if proc_img:
+                    st.write("Processed")
+                    st.image(proc_img, use_column_width=True)
+                else:
+                    st.error("Preprocess failed")
+                    return
+            if st.button("🎥 Generate"):
+                with st.spinner("Generating video..."):
+                    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as temp_file:
+                        proc_img.save(temp_file.name, format='PNG')
+                        try:
+                            client = Client("awacke1/stable-video-diffusion", hf_token=os.environ.get("HUGGINGFACE_TOKEN"))
+                            result = client.predict(
+                                image=temp_file.name,
+                                seed=seed if seed is not None else int(time.time() * 1000),
+                                randomize_seed=seed is None,
+                                motion_bucket_id=motion,
+                                fps_id=fps,
+                                api_name="/video"
+                            )
+                            if result and isinstance(result, tuple) and len(result) >= 1:
+                                video_path = result[0].get('video') if isinstance(result[0], dict) else None
+                                if video_path and os.path.exists(video_path):
+                                    video_filename = f"generated_video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+                                    shutil.copy(video_path, video_filename)
+                                    st.success(f"Video generated! 🎉")
+                                    st.video(video_filename)
+                                    if container:
+                                        video_record = {
+                                            "id": generate_unique_id(),
+                                            "pk": generate_unique_id(),
+                                            "type": "generated_video",
+                                            "filename": video_filename,
+                                            "seed": seed if seed is not None else "random",
+                                            "motion": motion,
+                                            "fps": fps,
+                                            "timestamp": datetime.now().isoformat()
+                                        }
+                                        success, message = insert_record(container, video_record)
+                                        if success:
+                                            st.success("DB record saved!")
+                                        else:
+                                            st.error(f"DB error: {message}")
+                                else:
+                                    st.error("Invalid result format")
+                            else:
+                                st.error("No result returned")
+                        except Exception as e:
+                            st.error(f"Video gen error: {str(e)}")
+                        finally:
+                            try:
+                                os.unlink(temp_file.name)
+                                st.write("Temp file removed")
+                            except Exception as e:
+                                st.warning(f"Cleanup error: {str(e)}")
+        except Exception as e:
+            st.error(f"Upload error: {str(e)}")
+
+# =============================================================================
+# ───────────── NEW ITEM & FIELD FUNCTIONS
+# =============================================================================
+def new_item_default(container):
+    new_id = generate_unique_id()
+    default_doc = {
+         "id": new_id,
+         "pk": new_id,
+         "name": "New Sample Document",
+         "content": "Start editing your document here...",
+         "timestamp": datetime.now().isoformat(),
+         "type": "sample"
+    }
+    success, message = insert_record(container, default_doc)
+    if success:
+         st.success("New sample document created! ✨")
+         return default_doc
+    else:
+         st.error("Error creating new item: " + message)
+         return None
+
+def auto_save_edit():
+    try:
+         edited_str = st.session_state.doc_editor
+         try:
+             json.loads(edited_str)
+         except Exception:
+             edited_str = sanitize_json_text(edited_str)
+         edited_doc = json.loads(edited_str)
+         container = st.session_state.current_container
+         container.upsert_item(edited_doc)
+         st.success("Auto-saved! 💾")
+    except Exception as e:
+         st.error(f"Auto-save error: {str(e)}")
+
+def add_field_to_doc():
+    key = st.session_state.new_field_key
+    value = st.session_state.new_field_value
+    try:
+         doc = json.loads(st.session_state.doc_editor)
+         doc[key] = value
+         st.session_state.doc_editor = json.dumps(doc, indent=2)
+         auto_save_edit()
+         st.success(f"Added field {key} 👍")
+    except Exception as e:
+         st.error(f"Error adding field: {str(e)}")
+
+# =============================================================================
+# ───────────── SEARCH RESULTS DISPLAY (Editable Code Editors)
+# =============================================================================
+def display_search_results(keyword, container):
+    results = vector_keyword_search(keyword, container)
+    st.markdown("### 🔍 Search Results")
+    for res in results:
+        doc_id = res.get("id", "")
+        exp = st.expander(f"Result {doc_id}")
+        with exp:
+            edited = st.text_area("Edit Document", value=json.dumps(res, indent=2), key=f"search_{doc_id}")
+            if st.button(f"💾 Save changes for {doc_id}", key=f"save_search_{doc_id}"):
+                try:
+                    updated_doc = json.loads(edited)
+                    container.upsert_item(body=updated_doc)
+                    st.success(f"Updated {doc_id}!")
+                    st.experimental_rerun()
+                except Exception as e:
+                    st.error(f"Error saving {doc_id}: {str(e)}")
+
+# =============================================================================
+# ───────────── DOCUMENTS LIST VIEW (Editable List with Sorting)
+# =============================================================================
+def edit_documents_list(container):
+    records = get_documents(container)
+    sort_option = st.selectbox("Sort by", ["Timestamp", "Name"], key="sort_option")
+    if sort_option == "Name":
+        records.sort(key=lambda r: r.get("name", "").lower())
+    else:
+        records.sort(key=lambda r: r.get("timestamp", ""), reverse=True)
+    data = []
+    for rec in records:
+        ts = rec.get("timestamp", "")
+        try:
+            dt = datetime.fromisoformat(ts)
+            formatted = dt.strftime("%I:%M %p %m/%d/%Y")
+        except Exception:
+            formatted = ts
+        data.append({
+            "ID": rec.get("id", ""),
+            "Name": rec.get("name", ""),
+            "Content": rec.get("content", "")[:100] + "..." if rec.get("content", "") else "",
+            "Timestamp": formatted
+        })
+    df = pd.DataFrame(data)
+    edited_df = st.data_editor(df[["Name", "Content", "Timestamp"]], key="docs_editor", num_rows="dynamic")
+    if st.button("💾 Save List Changes"):
+        for idx, row in edited_df.iterrows():
+            original = data[idx]
+            if row["Name"] != original["Name"] or row["Content"] != original["Content"]:
+                doc_id = original["ID"]
+                doc = next((r for r in records if r.get("id") == doc_id), None)
+                if doc:
+                    doc["name"] = row["Name"]
+                    doc["content"] = row["Content"]
+                    success, message = update_record(container, doc)
+                    if success:
+                        st.success(f"Updated {doc_id} 👍")
+                    else:
+                        st.error(f"Error updating {doc_id}: {message}")
+        st.experimental_rerun()
+
+# =============================================================================
+# ───────────── SEARCH DOCUMENTS UI (Enter Key triggers search)
+# =============================================================================
 def search_documents_ui(container):
     with st.sidebar.form("search_form"):
         keyword = st.text_input("Search Keyword", key="search_keyword")
@@ -945,7 +1140,9 @@ def search_documents_ui(container):
         if submitted and keyword:
             display_search_results(keyword, container)
 
-# 🛠️🛠️🛠️ MAIN FUNCTION 🛠️🛠️🛠️
+# =============================================================================
+# ───────────── MAIN FUNCTION ─────────────
+# =============================================================================
 def main():
     st.markdown("### 🐙 GitCosmos - Cosmos & Git Hub")
     st.markdown(f"[🔗 Portal]({CosmosDBUrl})")
@@ -958,42 +1155,6 @@ def main():
     else:
         st.error("Missing Cosmos Key 🔑❌")
         return
-
-    # ── CosmosDB Demo Features in Sidebar ──
-    st.sidebar.markdown("## CosmosDB Demo Features")
-    demo_feature = st.sidebar.selectbox("Select a Demo", 
-                                        ["Select", "Create Database", "Create Container", "Create Analytical Container",
-                                         "Get Existing Container", "Insert Data", "Delete Data", "Query Database",
-                                         "Parameterized Query", "Get Database Properties", "Get Throughput",
-                                         "Modify Container Properties", "Item Response Headers"],
-                                        key="demo_select")
-    if demo_feature != "Select":
-        if demo_feature == "Create Database":
-            demo_create_database()
-        elif demo_feature == "Create Container":
-            demo_create_container()
-        elif demo_feature == "Create Analytical Container":
-            demo_create_analytical_container()
-        elif demo_feature == "Get Existing Container":
-            demo_get_existing_container()
-        elif demo_feature == "Insert Data":
-            demo_insert_data()
-        elif demo_feature == "Delete Data":
-            demo_delete_data()
-        elif demo_feature == "Query Database":
-            demo_query_database()
-        elif demo_feature == "Parameterized Query":
-            demo_parameterized_query()
-        elif demo_feature == "Get Database Properties":
-            demo_get_db_properties()
-        elif demo_feature == "Get Throughput":
-            demo_get_throughput()
-        elif demo_feature == "Modify Container Properties":
-            demo_modify_container_properties()
-        elif demo_feature == "Item Response Headers":
-            demo_item_response_headers()
-
-    # ── Existing Sidebar Items (Item Management, File Management, etc.) ──
     st.sidebar.markdown("## 🛠️ Item Management")
     if st.sidebar.button("New Item"):
         if st.session_state.get("current_container"):
@@ -1023,7 +1184,10 @@ def main():
     search_documents_ui(st.session_state.get("current_container"))
     show_sidebar_data_grid()
 
-    # Continue with your other UI sections (navigation, file management, document editing, etc.)
+
+    
+    if st.session_state.get("current_container"):
+        edit_names_grid(st.session_state.current_container)
     try:
         if st.session_state.get("client") is None:
             st.session_state.client = CosmosClient(ENDPOINT, credential=st.session_state.primary_key)
@@ -1050,12 +1214,7 @@ def main():
                     submitted = st.form_submit_button("Create Container")
                     if submitted:
                         analytical_ttl = -1 if new_analytical else None
-                        # Using create_container method directly (adjust if you have an advanced function)
-                        new_container = database.create_container(
-                            id=new_container_id,
-                            partition_key=PartitionKey(path=new_partition_key),
-                            analytical_storage_ttl=analytical_ttl
-                        )
+                        new_container = create_new_container(database, new_container_id, new_partition_key, analytical_storage_ttl=analytical_ttl)
                         if new_container:
                             st.success(f"Container '{new_container_id}' created.")
                             default_id = generate_unique_id()
@@ -1155,12 +1314,16 @@ def main():
                                         st.error(message)
                                 except Exception as e:
                                     st.error(f"Delete err: {str(e)}")
+                        if "delete_log" in st.session_state and st.session_state.delete_log:
+                            st.subheader("Delete Log")
+                            for log_entry in st.session_state.delete_log[-5:]:
+                                st.write(log_entry)
                 elif selected_view == 'Run AI':
                     st.markdown("#### 🤖 Run AI")
                     ai_query = st.text_area("Enter your query for ArXiv search:", key="arxiv_query", height=100)
                     if st.button("Send"):
                         st.session_state.last_query = ai_query
-                        st.info("Performing AI lookup (function not implemented in this demo)...")
+                        perform_ai_lookup(ai_query, vocal_summary=True, extended_refs=False, titles_summary=True, full_audio=True, useArxiv=True, useArxivAudio=False)
                 elif selected_view == 'Clone':
                     st.markdown("#### 📄 Clone")
                     if documents: