supabase update

app.py

@@ -1,10 +1,14 @@
 import os
 import io
 import re
+import logging
 from typing import List, Dict, Any
 from fastapi import FastAPI, Request
 from slack_bolt import App
 from slack_bolt.adapter.fastapi import SlackRequestHandler
+from slack_bolt.oauth import OAuthFlow
+from slack_bolt.oauth.oauth_state_store import FileOAuthStateStore
+from slack_bolt.installer import Installer
 from sentence_transformers import SentenceTransformer
 from transformers import pipeline
 from supabase import create_client, Client
@@ -12,6 +16,12 @@ import pypdf
 from docx import Document
 import requests
 import uvicorn
+from slack_sdk.web import WebClient
+from slack_sdk.oauth import AuthorizeUrlGenerator
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # Load secrets from environment variables
 SUPABASE_URL = os.environ.get("SUPABASE_URL")
@@ -29,7 +39,53 @@ if HF_TOKEN:
 
 supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
 
-app = App(token=SLACK_BOT_TOKEN, signing_secret=SLACK_SIGNING_SECRET)
+# Supabase Installation Store
+class SupabaseInstallationStore:
+    def __init__(self, supabase_client):
+        self.supabase = supabase_client
+
+    def save(self, installation):
+        data = {
+            "team_id": installation.team_id,
+            "bot_token": installation.bot_token,
+            "bot_user_id": installation.bot_user_id,
+            "bot_scopes": installation.bot_scopes,
+            "app_id": installation.app_id,
+        }
+        self.supabase.table("installations").upsert(data, on_conflict="team_id").execute()
+        logger.info(f"Saved installation for team: {installation.team_id}")
+
+    def fetch_installation(self, team_id):
+        result = self.supabase.table("installations").select("*").eq("team_id", team_id).execute()
+        if not result.data:
+            return None
+        # Reconstruct Installation object (simplified; use full Bolt types in prod)
+        from slack_bolt.models.installation import Installation
+        return Installation(
+            app_id=result.data[0]["app_id"],
+            enterprise_id=None,
+            team_id=team_id,
+            user_id=None,
+            bot_token=result.data[0]["bot_token"],
+            bot_user_id=result.data[0]["bot_user_id"],
+            bot_scopes=result.data[0]["bot_scopes"],
+            incoming_webhook=None,
+        )
+
+    def delete_installation(self, team_id):
+        self.supabase.table("installations").delete().eq("team_id", team_id).execute()
+
+# Initialize installation store
+installation_store = SupabaseInstallationStore(supabase)
+
+# Initialize App with installation store
+app = App(
+    client_id=SLACK_CLIENT_ID,
+    client_secret=SLACK_CLIENT_SECRET,
+    signing_secret=SLACK_SIGNING_SECRET,
+    installation_store=installation_store,
+)
+
 api = FastAPI()
 
 print("Loading embedding model...")
@@ -74,24 +130,44 @@ def embed_text(text: str) -> List[float]:
 def store_embeddings(chunks: List[str]):
     for chunk in chunks:
         embedding = embed_text(chunk)
-        supabase.table("documents").insert({
-            "content": chunk,
-            "embedding": embedding
-        }).execute()
+        try:
+            supabase.table("documents").insert({
+                "content": chunk,
+                "embedding": embedding
+            }).execute()
+        except Exception as e:
+            logger.error(f"Failed to insert chunk '{chunk[:100]}...' into Supabase: {str(e)}")
+
+def is_table_empty() -> bool:
+    try:
+        result = supabase.table("documents").select("count", count="exact").execute()
+        count = result.data[0]["count"] if result.data else 0
+        return count == 0
+    except Exception as e:
+        logger.error(f"Error checking table emptiness: {str(e)}")
+        return True  # Assume empty on error to be safe
 
 def search_documents(query: str, match_count: int = 5) -> List[Dict[str, Any]]:
     query_embedding = embed_text(query)
-    result = supabase.rpc("match_documents", {
-        "query_embedding": query_embedding,
-        "match_count": match_count
-    }).execute()
-    return result.data
+    try:
+        result = supabase.rpc("match_documents", {
+            "query_embedding": query_embedding,
+            "match_count": match_count
+        }).execute()
+        return result.data
+    except Exception as e:
+        logger.error(f"Error searching documents for query '{query}': {str(e)}")
+        return []
 
 def answer_question(question: str, context: str) -> str:
     if not context.strip():
         return "No relevant documents found."
-    result = qa_pipeline(question=question, context=context[:4096])
-    return result['answer']
+    try:
+        result = qa_pipeline(question=question, context=context[:4096])
+        return result['answer']
+    except Exception as e:
+        logger.error(f"Error in QA pipeline for question '{question}' and context length {len(context)}: {str(e)}")
+        return "Error generating answer from context."
 
 @app.event("file_shared")
 def handle_file_shared(event, say, client):
@@ -103,10 +179,11 @@ def handle_file_shared(event, say, client):
     file_url = file_data.get("url_private_download")
     
     if not file_url:
+        say("No download URL available for the file.")
         return
     
     try:
-        file_content = download_slack_file(file_url, SLACK_BOT_TOKEN)
+        file_content = download_slack_file(file_url, client.token)
         
         text = ""
         if "pdf" in file_type:
@@ -117,23 +194,81 @@ def handle_file_shared(event, say, client):
             say("Unsupported file type. Please upload PDF or DOCX files.")
             return
         
+        if not text.strip():
+            say("No text could be extracted from the file.")
+            return
+        
         chunks = chunk_text(text)
         store_embeddings(chunks)
         
         say(f"✅ File processed successfully! Added {len(chunks)} chunks to knowledge base.")
     except Exception as e:
+        logger.error(f"Detailed error in file_shared handler for file_id {file_id}, mimetype {file_type}: {str(e)}")
         say(f"❌ Error processing file: {str(e)}")
 
 @app.event("app_mention")
-def handle_mention(event, say):
+def handle_mention(event, say, client):
     text = event["text"]
     user_query = re.sub(r'<@[A-Z0-9]+>', '', text).strip()
     
+    # Check if the mention includes a file share
+    files = event.get("files", [])
+    if files:
+        # Handle file in mention context (process it similarly to file_shared)
+        for file_info in files:
+            file_id = file_info["id"]
+            file_type = file_info.get("mimetype", "")
+            file_url = file_info.get("url_private_download")
+            
+            if not file_url:
+                say("No download URL available for the attached file.")
+                continue
+            
+            try:
+                file_content = download_slack_file(file_url, client.token)
+                
+                extracted_text = ""
+                if "pdf" in file_type:
+                    extracted_text = extract_text_from_pdf(file_content)
+                elif "wordprocessingml" in file_type or "msword" in file_type:
+                    extracted_text = extract_text_from_docx(file_content)
+                else:
+                    say("Unsupported file type in mention. Please upload PDF or DOCX files.")
+                    continue
+                
+                if not extracted_text.strip():
+                    say("No text could be extracted from the attached file.")
+                    continue
+                
+                chunks = chunk_text(extracted_text)
+                store_embeddings(chunks)
+                
+                say(f"✅ Attached file processed successfully! Added {len(chunks)} chunks to knowledge base.")
+                # If there's also a query, proceed to answer below
+            except Exception as e:
+                logger.error(f"Detailed error processing file in mention for file_id {file_id}: {str(e)}")
+                say(f"❌ Error processing attached file: {str(e)}")
+    
     if not user_query:
-        say("Please ask me a question!")
+        say("Please ask me a question after mentioning me!")
         return
     
+    # Send typing indicator
+    try:
+        client.chat_postMessage(
+            channel=event["channel"],
+            as_user=True,
+            typing=True  # This triggers the typing indicator
+        )
+    except Exception as e:
+        logger.warning(f"Failed to send typing indicator: {str(e)}")
+    
     try:
+        # Check if table is empty
+        if is_table_empty():
+            say("My knowledge base is empty. Please share some PDF or DOCX files first so I can learn!")
+            return
+        
         results = search_documents(user_query, match_count=5)
         
         if not results:
@@ -145,6 +280,7 @@ def handle_mention(event, say):
         
         say(f"💡 *Answer:* {answer}")
     except Exception as e:
+        logger.error(f"Detailed error in app_mention handler for query '{user_query}': {str(e)}")
         say(f"❌ Error answering question: {str(e)}")
 
 handler = SlackRequestHandler(app)
@@ -161,21 +297,25 @@ async def root():
 async def health():
     return {"status": "ok"}
 
+@api.get("/slack/install")
+async def install_url():
+    generator = AuthorizeUrlGenerator(
+        client_id=SLACK_CLIENT_ID,
+        scopes=["app_mentions:read", "files:read", "chat:write", "im:read", "im:write", "channels:read"]
+    )
+    return {"install_url": generator.generate(state="state")}
+
 @api.get("/slack/oauth/callback")
 async def oauth_callback(code: str, state: str = None):
-    # Handle OAuth installation
-    from slack_sdk.oauth import AuthorizeUrlGenerator
-    from slack_sdk.web import WebClient
-    
-    client = WebClient()
-    oauth_response = client.oauth_v2_access(
+    # Use Bolt's installer to handle and save
+    installer = Installer(
         client_id=SLACK_CLIENT_ID,
         client_secret=SLACK_CLIENT_SECRET,
-        code=code
+        signing_secret=SLACK_SIGNING_SECRET,
+        installation_store=installation_store,
     )
-    
-    # Save the token for this workspace
-    return {"status": "success", "team_id": oauth_response["team"]["id"]}
+    installer.run(code)
+    return {"status": "success"}
 
 if __name__ == "__main__":
     uvicorn.run(api, host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))