Update app.py

app.py

@@ -13,7 +13,7 @@ from calendar_rag import (
 )
 
 # Define repository path
-os.environ["GITHUB_REPO_PATH"] = r"D:\Last SWU\swu-chat-bot-project"
+os.environ["GITHUB_REPO_PATH"] = "D:\Last SWU\swu-chat-bot-project"
 
 # Initialize global state
 if 'all_history' not in st.session_state:
@@ -131,66 +131,60 @@ def load_qa_history():
 
 def save_qa_history(history_entry):
     """
-    Save QA history entry to local JSON file and push to GitHub with improved error handling
-    and configurable paths.
+    Save QA history to Git with improved authentication handling.
     """
     try:
-        # Get absolute paths
-        current_dir = Path.cwd()
-        history_file = current_dir / "qa_history.json"
-        repo_path = Path(os.getenv('GITHUB_REPO_PATH', ''))
+        repo_path = Path(os.getenv('GITHUB_REPO_PATH', '')).resolve()
+        history_file = repo_path / "qa_history.json"
         
-        if not repo_path.exists():
-            print(f"Repository path does not exist: {repo_path}")
-            return False
-            
-        # Initialize or load existing history
+        # Load existing history
         history_data = []
         if history_file.exists():
             try:
                 with open(history_file, "r", encoding="utf-8") as f:
                     history_data = json.load(f)
             except json.JSONDecodeError:
-                print("Error reading existing history file, starting fresh")
-                pass
+                print("Creating new history file")
         
-        # Append new entries
+        # Update history
         if isinstance(history_entry, list):
             history_data.extend(history_entry)
         else:
             history_data.append(history_entry)
         
-        # Save locally first
+        # Save updated history
         with open(history_file, "w", encoding="utf-8") as f:
             json.dump(history_data, f, ensure_ascii=False, indent=2)
         
-        # Copy file to repository if it's in a different location
-        repo_history_file = repo_path / "qa_history.json"
-        if history_file != repo_history_file:
-            import shutil
-            shutil.copy2(history_file, repo_history_file)
-        
         # Git operations
         try:
-            repo = Repo(repo_path)
-            repo.git.add(str(repo_history_file))
+            repo = Repo(str(repo_path))
+            repo.index.add([str(history_file)])
             
             if repo.is_dirty():
-                repo.index.commit("Update QA history")
+                commit = repo.index.commit("Update QA history")
                 origin = repo.remote('origin')
-                origin.push()
-                print("Successfully pushed to GitHub")
+                
+                try:
+                    origin.push()
+                    print(f"Successfully pushed commit {commit.hexsha}")
+                    return True
+                except git.GitCommandError as push_error:
+                    if "Authentication failed" in str(push_error):
+                        print("Authentication failed - please check your Git credentials")
+                    else:
+                        print(f"Push failed: {push_error}")
+                    return False
             else:
                 print("No changes to commit")
-                
-            return True
+                return True
                 
         except Exception as git_error:
             print(f"Git operation failed: {str(git_error)}")
             return False
             
     except Exception as e:
-        print(f"Error in save_qa_history: {str(e)}")
+        print(f"Save operation failed: {str(e)}")
         return False
 
 def add_to_qa_history(query: str, answer: str):
@@ -268,55 +262,78 @@ def display_chat_history():
 
 def initialize_github_sync():
     """
-    Initialize GitHub repository connection and validate configuration.
-    Returns True if GitHub sync is properly configured, False otherwise.
+    Initialize GitHub repository connection with authentication handling.
     """
     try:
-        # Get repository path
-        repo_path = Path(os.getenv('GITHUB_REPO_PATH', ''))
+        # Get and normalize repository path
+        repo_path = Path(os.getenv('GITHUB_REPO_PATH', '')).resolve()
+        print(f"Initializing repo at: {repo_path}")
         
-        # Validate repository path
-        if not repo_path or not repo_path.exists():
-            print(f"Repository directory does not exist: {repo_path}")
+        if not repo_path.exists():
+            print(f"Repository directory not found: {repo_path}")
             return False
             
         try:
             # Initialize repository
-            repo = Repo(repo_path)
+            repo = Repo(str(repo_path))
             
-            # Ensure it's a valid git repository
-            if not repo.git_dir:
-                print("Invalid Git repository")
+            # Verify .git directory
+            if not (repo_path / '.git').exists():
+                print(".git directory not found")
                 return False
                 
-            # Check for origin remote
+            # Check remote configuration
             try:
                 origin = repo.remote('origin')
-                # Validate origin URL
-                if not origin.urls:
-                    print("Remote 'origin' has no URL configured")
+                urls = list(origin.urls)
+                if not urls:
+                    print("Remote 'origin' has no URL")
                     return False
-            except ValueError:
-                print("Remote 'origin' not found")
-                return False
+                    
+                expected_url = "https://github.com/jirasaksaimekJijo/swu-chat-bot-project.git"
+                if expected_url not in urls:
+                    print(f"Unexpected remote URL: {urls[0]}")
+                    return False
+                    
+                print(f"Verified remote URL: {urls[0]}")
                 
-            # Test Git operations
-            try:
-                # Test git status
-                repo.git.status()
-                # Test if we can get the current branch
-                repo.active_branch
-                return True
-            except Exception as git_error:
-                print(f"Git operations test failed: {str(git_error)}")
+                # Test Git operations
+                try:
+                    repo.git.status()
+                    print("Git status check passed")
+                    
+                    # Try to create a test commit to verify write access
+                    test_file = repo_path / '.git' / 'test_sync'
+                    try:
+                        test_file.touch()
+                        repo.index.add([str(test_file)])
+                        repo.index.commit("Test sync commit")
+                        origin.push()
+                        test_file.unlink()  # Clean up test file
+                        print("Push test successful")
+                    except git.GitCommandError as push_error:
+                        if "Authentication failed" in str(push_error):
+                            print("Authentication failed - please check your Git credentials")
+                            return False
+                        print(f"Push test failed: {push_error}")
+                        return False
+                        
+                    return True
+                    
+                except Exception as git_error:
+                    print(f"Git operations failed: {str(git_error)}")
+                    return False
+                    
+            except ValueError:
+                print("Remote 'origin' not configured")
                 return False
                 
         except Exception as repo_error:
-            print(f"Error validating Git repository: {str(repo_error)}")
+            print(f"Repository validation failed: {str(repo_error)}")
             return False
             
     except Exception as e:
-        print(f"Error initializing GitHub sync: {str(e)}")
+        print(f"Initialization failed: {str(e)}")
         return False
         
 def main():