Update app.py

app.py

@@ -2,607 +2,198 @@ import gradio as gr
 import regex as re
 import csv
 import pandas as pd
-from typing import Dict, List, Tuple, Optional, Any
+from typing import List, Dict, Tuple, Optional
 import logging
-from pathlib import Path
+from datetime import datetime
 import os
-
-from analyzer import (
-    combine_repo_files_for_llm,
-    analyze_combined_file,
-    parse_llm_json_response,
-    analyze_code
-)
-from hf_utils import download_space_repo, search_top_spaces
-from chatbot_page import chat_with_user, extract_keywords_from_conversation
+from huggingface_hub import HfApi, SpaceCard
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+import json
 
 # Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # Constants
-CHATBOT_SYSTEM_PROMPT = (
-    "You are a helpful assistant. Your goal is to help the user describe their ideal open-source repo. "
-    "Ask questions to clarify what they want, their use case, preferred language, features, etc. "
-    "When the user clicks 'End Chat', analyze the conversation and return about 5 keywords for repo search. "
-    "Return only the keywords as a comma-separated list."
-)
-
-CHATBOT_INITIAL_MESSAGE = (
-    "Hello! Please tell me about your ideal Hugging Face repo. "
-    "What use case, preferred language, or features are you looking for?"
-)
+CSV_FILE = "repo_ids.csv"
+CHATBOT_SYSTEM_PROMPT = """You are a helpful AI assistant that analyzes Hugging Face repositories. 
+Your task is to help users understand repositories, extract key information, and provide insights.
+Be concise, clear, and focus on the most important aspects of each repository."""
 
-# State management
 class AppState:
+    """Simple state management for the application."""
     def __init__(self):
         self.repo_ids: List[str] = []
         self.current_repo_idx: int = 0
-        self.generated_keywords: List[str] = []
-        self.analysis_results: Dict[str, Dict[str, Any]] = {}
-        self.chat_history: List[Tuple[str, str]] = []
-
-    def reset(self):
-        self.__init__()
+        self.chat_history: List[Dict[str, str]] = []
 
-# Helper functions
-def read_csv_as_text(csv_filename: str) -> pd.DataFrame:
-    """Read CSV file and return as DataFrame with string dtype."""
+def read_csv_as_text(filename: str) -> pd.DataFrame:
+    """Read CSV file and return as DataFrame."""
     try:
-        return pd.read_csv(csv_filename, dtype=str)
+        return pd.read_csv(filename)
     except Exception as e:
-        logger.error(f"Error reading CSV file {csv_filename}: {e}")
+        logger.error(f"Error reading CSV: {e}")
         return pd.DataFrame(columns=["repo id", "strength", "weaknesses", "speciality", "relevance rating"])
 
-def write_repos_to_csv(repo_ids: List[str], csv_filename: str = "repo_ids.csv") -> None:
-    """Write repo IDs to CSV file."""
+def write_repos_to_csv(repo_ids: List[str]) -> None:
+    """Write repository IDs to CSV file."""
     try:
-        with open(csv_filename, mode="w", newline='', encoding="utf-8") as csvfile:
-            writer = csv.writer(csvfile)
+        with open(CSV_FILE, 'w', newline='') as f:
+            writer = csv.writer(f)
             writer.writerow(["repo id", "strength", "weaknesses", "speciality", "relevance rating"])
             for repo_id in repo_ids:
                 writer.writerow([repo_id, "", "", "", ""])
     except Exception as e:
-        logger.error(f"Error writing to CSV file {csv_filename}: {e}")
+        logger.error(f"Error writing to CSV: {e}")
 
-def process_repo_input(text: str, state: AppState) -> pd.DataFrame:
-    """Process input text containing repo IDs and update state."""
-    if not text:
-        state.repo_ids = []
-        state.current_repo_idx = 0
-        return pd.DataFrame(columns=["repo id", "strength", "weaknesses", "speciality", "relevance rating"])
-    
-    repo_ids = [repo.strip() for repo in re.split(r'[\n,]+', text) if repo.strip()]
-    state.repo_ids = repo_ids
-    state.current_repo_idx = 0
-    
-    write_repos_to_csv(repo_ids)
-    return read_csv_as_text("repo_ids.csv")
+def search_top_spaces(keyword: str, limit: int = 5) -> List[str]:
+    """Search for repositories by keyword."""
+    try:
+        api = HfApi()
+        spaces = api.list_spaces(search=keyword, limit=limit)
+        return [space.id for space in spaces]
+    except Exception as e:
+        logger.error(f"Error searching spaces: {e}")
+        return []
 
-def analyze_single_repo(repo_id: str) -> Tuple[str, str, Dict[str, Any]]:
-    """Analyze a single repository and return combined content, summary, and analysis results."""
+def analyze_repo(repo_id: str) -> Tuple[str, str]:
+    """Analyze a single repository."""
     try:
-        download_space_repo(repo_id, local_dir="repo_files")
-        txt_path = combine_repo_files_for_llm()
-        
-        with open(txt_path, "r", encoding="utf-8") as f:
-            combined_content = f.read()
-            
-        llm_output = analyze_combined_file(txt_path)
-        last_start = llm_output.rfind('{')
-        last_end = llm_output.rfind('}')
-        
-        final_json_str = llm_output[last_start:last_end+1] if last_start != -1 and last_end != -1 and last_end > last_start else llm_output
-        llm_json = parse_llm_json_response(final_json_str)
-        
-        if isinstance(llm_json, dict) and "error" not in llm_json:
-            strengths = llm_json.get("strength", "")
-            weaknesses = llm_json.get("weaknesses", "")
-            summary = f"JSON extraction: SUCCESS\n\nStrengths:\n{strengths}\n\nWeaknesses:\n{weaknesses}"
-        else:
-            summary = f"JSON extraction: FAILED\nRaw: {llm_json.get('raw', '') if isinstance(llm_json, dict) else llm_json}"
-            
-        return combined_content, summary, llm_json
-        
+        api = HfApi()
+        space = api.get_space(repo_id)
+        card = SpaceCard.load(repo_id)
+        
+        content = f"""
+        Repository: {repo_id}
+        Title: {card.title}
+        Description: {card.description}
+        Tags: {', '.join(card.tags)}
+        """
+        
+        summary = f"Analysis of {repo_id}:\n"
+        summary += f"- Title: {card.title}\n"
+        summary += f"- Main focus: {card.description[:200]}...\n"
+        summary += f"- Key tags: {', '.join(card.tags[:5])}\n"
+        
+        return content, summary
     except Exception as e:
         logger.error(f"Error analyzing repo {repo_id}: {e}")
-        return "", f"Error analyzing repo: {e}", {"error": str(e)}
+        return f"Error analyzing {repo_id}", f"Error: {str(e)}"
 
-def update_csv_with_analysis(repo_id: str, analysis_results: Dict[str, Any], csv_filename: str = "repo_ids.csv") -> pd.DataFrame:
-    """Update CSV file with analysis results for a repository."""
+def chat_with_user(message: str, history: List[Dict[str, str]], system_prompt: str) -> str:
+    """Simple chat response."""
     try:
-        df = read_csv_as_text(csv_filename)
-        updated = False
-        
-        for idx, row in df.iterrows():
-            if row["repo id"] == repo_id:
-                if isinstance(analysis_results, dict) and "error" not in analysis_results:
-                    df.at[idx, "strength"] = analysis_results.get("strength", "")
-                    df.at[idx, "weaknesses"] = analysis_results.get("weaknesses", "")
-                    df.at[idx, "speciality"] = analysis_results.get("speciality", "")
-                    df.at[idx, "relevance rating"] = analysis_results.get("relevance rating", "")
-                updated = True
-                break
-                
-        if not updated and isinstance(analysis_results, dict) and "error" not in analysis_results:
-            new_row = {
-                "repo id": repo_id,
-                "strength": analysis_results.get("strength", ""),
-                "weaknesses": analysis_results.get("weaknesses", ""),
-                "speciality": analysis_results.get("speciality", ""),
-                "relevance rating": analysis_results.get("relevance rating", "")
-            }
-            df = pd.concat([df, pd.DataFrame([new_row])], ignore_index=True)
-            
-        df.to_csv(csv_filename, index=False)
-        return df
-        
+        # For now, return a simple response
+        return f"I understand you're asking about: {message}. How can I help you analyze this repository?"
     except Exception as e:
-        logger.error(f"Error updating CSV for repo {repo_id}: {e}")
-        return read_csv_as_text(csv_filename)
-
-def show_combined_repo_and_llm(state: AppState) -> Tuple[str, str, pd.DataFrame]:
-    """Show combined repo content and LLM analysis for current repo."""
-    if not state.repo_ids:
-        return "No repo ID available. Please submit repo IDs first.", "", pd.DataFrame()
-        
-    if state.current_repo_idx >= len(state.repo_ids):
-        return "All repo IDs have been processed.", "", read_csv_as_text("repo_ids.csv")
-        
-    repo_id = state.repo_ids[state.current_repo_idx]
-    combined_content, summary, analysis_results = analyze_single_repo(repo_id)
-    df = update_csv_with_analysis(repo_id, analysis_results)
-    
-    state.current_repo_idx += 1
-    return combined_content, summary, df
+        logger.error(f"Error in chat: {e}")
+        return "I apologize, but I encountered an error. Please try again."
 
-def keyword_search_and_update(keyword: str, state: AppState) -> pd.DataFrame:
-    """Search for repos using keywords and update state."""
-    if not keyword:
-        return pd.DataFrame(columns=["repo id", "strength", "weaknesses", "speciality", "relevance rating"])
-        
-    keyword_list = [k.strip() for k in re.split(r'[\n,]+', keyword) if k.strip()]
-    repo_ids = []
-    
-    for kw in keyword_list:
-        repo_ids.extend(search_top_spaces(kw, limit=5))
-        
-    # Remove duplicates while preserving order
-    seen = set()
-    unique_repo_ids = []
-    for rid in repo_ids:
-        if rid not in seen:
-            unique_repo_ids.append(rid)
-            seen.add(rid)
-            
-    state.repo_ids = unique_repo_ids
-    state.current_repo_idx = 0
-    
-    write_repos_to_csv(unique_repo_ids)
-    return read_csv_as_text("repo_ids.csv")
-
-# UI Components
 def create_ui() -> gr.Blocks:
-    """Create the Gradio interface."""
+    """Create a simplified Gradio interface."""
     state = gr.State(AppState())
     
     with gr.Blocks(title="Hugging Face Repo Analyzer", theme=gr.themes.Soft()) as app:
         gr.Markdown("# Hugging Face Repository Analyzer")
         
-        # Navigation state
-        current_page = gr.State("start")
-        
-        # Start Page
-        with gr.Group(visible=True) as start_page:
-            gr.Markdown("""
-            # Welcome to the Hugging Face Repository Analyzer!
-            
-            This tool helps you analyze and understand Hugging Face repositories. You can:
-            - Enter repository IDs directly
-            - Search repositories using keywords
-            - Chat with an AI assistant to find the perfect repository
-            - Get detailed analysis of repositories
-            
-            Click 'Start Analysis' to begin!
-            """)
-            with gr.Row():
-                start_btn = gr.Button("Start Analysis", variant="primary")
-                help_btn = gr.Button("View Help Guide", variant="secondary")
-            
-        # Help Guide
-        with gr.Group(visible=False) as help_page:
-            gr.Markdown("""
-            # Help Guide
-            
-            ## Quick Start
-            1. Enter repository IDs or search by keywords
-            2. Start the analysis
-            3. Review the results
-            
-            ## Features
-            - **Repository Analysis**: Get detailed insights about repositories
-            - **Keyword Search**: Find repositories matching your criteria
-            - **AI Assistant**: Chat to find the perfect repository
-            - **Comparison**: Compare repositories side by side
-            
-            ## Keyboard Shortcuts
-            - `Ctrl + Enter`: Send message in chat
-            - `Ctrl + S`: Start new analysis
-            - `Ctrl + H`: Toggle help guide
-            """)
-            back_btn = gr.Button("Back to Start", variant="primary")
-            
-        # Input Page
-        with gr.Group(visible=False) as input_page:
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### Enter Repository IDs")
-                    repo_id_input = gr.Textbox(
-                        label="Enter repo IDs (comma or newline separated)",
-                        lines=5,
-                        placeholder="repo1, repo2\nrepo3"
-                    )
-                    submit_btn = gr.Button("Submit Repo IDs", variant="primary")
-                    submit_status = gr.Textbox(label="Status", visible=False)
-                    
-                with gr.Column():
-                    gr.Markdown("### Or Search by Keywords")
-                    keyword_input = gr.Textbox(
-                        label="Enter keywords to search",
-                        lines=3,
-                        placeholder="Enter keywords separated by commas"
-                    )
-                    search_btn = gr.Button("Search by Keywords", variant="primary")
-                    search_status = gr.Textbox(label="Status", visible=False)
-                    
-            df_output = gr.Dataframe(
-                headers=["repo id", "strength", "weaknesses", "speciality", "relevance rating"],
-                datatype=["str", "str", "str", "str", "str"]
-            )
-            with gr.Row():
-                analyze_btn = gr.Button("Start Analysis", variant="primary")
-                analyze_status = gr.Textbox(label="Status", visible=False)
-                compare_btn = gr.Button("Compare Repositories", variant="secondary")
-            
-        # Analysis Page
-        with gr.Group(visible=False) as analysis_page:
-            gr.Markdown("### Repository Analysis")
-            progress = gr.Slider(
-                minimum=0,
-                maximum=100,
-                value=0,
-                label="Analysis Progress",
-                interactive=False
-            )
-            with gr.Row():
-                with gr.Column():
-                    content_output = gr.Textbox(label="Repository Content", lines=10)
-                with gr.Column():
-                    summary_output = gr.Textbox(label="Analysis Summary", lines=10)
-            with gr.Row():
-                next_btn = gr.Button("Analyze Next Repository", variant="primary")
-                next_status = gr.Textbox(label="Status", visible=False)
-                finish_btn = gr.Button("Finish Analysis", variant="secondary")
-                export_btn = gr.Button("Export Results", variant="secondary")
-                export_status = gr.Textbox(label="Status", visible=False)
-            
-        # Comparison Page
-        with gr.Group(visible=False) as comparison_page:
-            gr.Markdown("### Repository Comparison")
-            with gr.Row():
-                with gr.Column():
-                    repo1_select = gr.Dropdown(
-                        label="Select First Repository",
-                        choices=[],
-                        interactive=True
-                    )
-                    repo1_content = gr.Textbox(label="Repository 1 Content", lines=10)
-                    repo1_summary = gr.Textbox(label="Repository 1 Summary", lines=10)
-                with gr.Column():
-                    repo2_select = gr.Dropdown(
-                        label="Select Second Repository",
-                        choices=[],
-                        interactive=True
-                    )
-                    repo2_content = gr.Textbox(label="Repository 2 Content", lines=10)
-                    repo2_summary = gr.Textbox(label="Repository 2 Summary", lines=10)
-            compare_btn = gr.Button("Compare", variant="primary")
-            back_to_analysis_btn = gr.Button("Back to Analysis", variant="secondary")
-            
-        # Chatbot Page
-        with gr.Group(visible=False) as chatbot_page:
-            gr.Markdown("### Chat with Assistant")
-            gr.Markdown("""
-            Tell me about your ideal repository. I'll help you find the perfect match!
-            What are you looking for? Consider:
-            - Your use case
-            - Preferred programming language
-            - Required features
-            - Any specific requirements
-            """)
-            chatbot = gr.Chatbot(
-                label="Chat with Assistant",
-                height=400,
-                type="messages"
-            )
-            msg = gr.Textbox(
-                label="Message",
-                placeholder="Type your message here...",
-                lines=2
-            )
-            with gr.Row():
-                send_btn = gr.Button("Send", variant="primary")
-                send_status = gr.Textbox(label="Status", visible=False)
-                end_chat_btn = gr.Button("End Chat", variant="secondary")
-                end_chat_status = gr.Textbox(label="Status", visible=False)
+        with gr.Row():
+            with gr.Column():
+                # Input Section
+                gr.Markdown("### Enter Repository Information")
+                repo_input = gr.Textbox(
+                    label="Enter repo IDs (comma or newline separated) or keywords to search",
+                    lines=5,
+                    placeholder="Enter repository IDs or keywords to search"
+                )
+                submit_btn = gr.Button("Submit", variant="primary")
+                status = gr.Textbox(label="Status", visible=True)
                 
-        # Results Page
-        with gr.Group(visible=False) as results_page:
-            gr.Markdown("### Analysis Results")
-            with gr.Row():
-                with gr.Column():
-                    results_df = gr.Dataframe(
-                        headers=["repo id", "strength", "weaknesses", "speciality", "relevance rating"],
-                        datatype=["str", "str", "str", "str", "str"]
-                    )
-                with gr.Column():
-                    gr.Markdown("### Repository Metrics")
-                    metrics_plot = gr.Plot(label="Repository Metrics")
-            with gr.Row():
-                restart_btn = gr.Button("Start New Analysis", variant="primary")
-                export_btn = gr.Button("Export Results", variant="secondary")
-                history_btn = gr.Button("View History", variant="secondary")
-            
-        # History Page
-        with gr.Group(visible=False) as history_page:
-            gr.Markdown("### Analysis History")
-            history_df = gr.Dataframe(
-                headers=["Date", "Repositories", "Keywords", "Results"],
-                datatype=["str", "str", "str", "str"]
-            )
-            back_to_results_btn = gr.Button("Back to Results", variant="primary")
-            
-        # Navigation functions
-        def navigate_to(page: str) -> List[gr.update]:
-            """Navigate to a specific page."""
-            updates = []
-            for p in ["start", "input", "analysis", "chatbot", "results", "help", "comparison", "history"]:
-                updates.append(gr.update(visible=(p == page)))
-            return updates
-            
-        # Event handlers
-        start_btn.click(
-            fn=lambda: navigate_to("input"),
-            inputs=[],
-            outputs=[start_page, input_page, analysis_page, chatbot_page, results_page, help_page, comparison_page, history_page]
-        )
-        
-        help_btn.click(
-            fn=lambda: navigate_to("help"),
-            inputs=[],
-            outputs=[start_page, input_page, analysis_page, chatbot_page, results_page, help_page, comparison_page, history_page]
-        )
-        
-        back_btn.click(
-            fn=lambda: navigate_to("start"),
-            inputs=[],
-            outputs=[start_page, input_page, analysis_page, chatbot_page, results_page, help_page, comparison_page, history_page]
-        )
-        
-        # Modified event handlers with status updates
-        def process_repo_input_with_status(text: str, state: AppState) -> Tuple[pd.DataFrame, str]:
-            """Process repo input with status update."""
-            df = process_repo_input(text, state)
-            return df, ""
-            
-        def keyword_search_with_status(keyword: str, state: AppState) -> Tuple[pd.DataFrame, str]:
-            """Search keywords with status update."""
+                # Results Section
+                df_output = gr.Dataframe(
+                    headers=["repo id", "strength", "weaknesses", "speciality", "relevance rating"],
+                    datatype=["str", "str", "str", "str", "str"]
+                )
+                
+                # Analysis Section
+                content_output = gr.Textbox(label="Repository Content", lines=10)
+                summary_output = gr.Textbox(label="Analysis Summary", lines=5)
+                
+                # Chat Section
+                chatbot = gr.Chatbot(label="Chat with Assistant", height=400)
+                msg = gr.Textbox(label="Message", placeholder="Ask about the repository...")
+                with gr.Row():
+                    send_btn = gr.Button("Send", variant="primary")
+                    clear_btn = gr.Button("Clear Chat", variant="secondary")
+        
+        def process_input(text: str, state: AppState) -> Tuple[pd.DataFrame, str, str, str]:
+            """Process input and return results."""
             try:
-                if not keyword:
-                    return pd.DataFrame(columns=["repo id", "strength", "weaknesses", "speciality", "relevance rating"]), ""
-                    
-                keyword_list = [k.strip() for k in re.split(r'[\n,]+', keyword) if k.strip()]
-                repo_ids = []
+                # Check if input is keywords or repo IDs
+                if any(kw in text.lower() for kw in ['search', 'find', 'look for']):
+                    # Handle as keyword search
+                    keywords = [k.strip() for k in re.split(r'[\n,]+', text) if k.strip()]
+                    repo_ids = []
+                    for kw in keywords:
+                        repo_ids.extend(search_top_spaces(kw, limit=5))
+                else:
+                    # Handle as repo IDs
+                    repo_ids = [rid.strip() for rid in re.split(r'[\n,]+', text) if rid.strip()]
                 
-                for kw in keyword_list:
-                    try:
-                        results = search_top_spaces(kw, limit=5)
-                        repo_ids.extend(results)
-                    except Exception as e:
-                        logger.error(f"Error searching for keyword {kw}: {e}")
-                        continue
+                # Remove duplicates
+                repo_ids = list(dict.fromkeys(repo_ids))
                 
-                # Remove duplicates while preserving order
-                seen = set()
-                unique_repo_ids = []
-                for rid in repo_ids:
-                    if rid not in seen:
-                        unique_repo_ids.append(rid)
-                        seen.add(rid)
+                if not repo_ids:
+                    return pd.DataFrame(), "No repositories found", "", ""
                 
-                state.repo_ids = unique_repo_ids
+                # Update state and CSV
+                state.repo_ids = repo_ids
                 state.current_repo_idx = 0
+                write_repos_to_csv(repo_ids)
+                
+                # Get first repo analysis
+                content, summary = analyze_repo(repo_ids[0])
                 
-                write_repos_to_csv(unique_repo_ids)
-                df = read_csv_as_text("repo_ids.csv")
-                return df, ""
+                return read_csv_as_text(CSV_FILE), f"Found {len(repo_ids)} repositories", content, summary
                 
             except Exception as e:
-                logger.error(f"Error in keyword search: {e}")
-                return pd.DataFrame(columns=["repo id", "strength", "weaknesses", "speciality", "relevance rating"]), f"Error: {str(e)}"
-            
-        def analyze_with_status(state: AppState) -> Tuple[str, str, pd.DataFrame, str]:
-            """Analyze with status update."""
-            content, summary, df = show_combined_repo_and_llm(state)
-            return content, summary, df, ""
-            
-        def send_message_with_status(user_message: str, history: List[Dict[str, str]], state: AppState) -> Tuple[List[Dict[str, str]], str, str]:
-            """Send message with status update."""
-            if not user_message:
-                return history, "", ""
-            history.append({"role": "user", "content": user_message})
-            response = chat_with_user(user_message, history, CHATBOT_SYSTEM_PROMPT)
+                logger.error(f"Error processing input: {e}")
+                return pd.DataFrame(), f"Error: {str(e)}", "", ""
+        
+        def send_message(message: str, history: List[Dict[str, str]], state: AppState) -> Tuple[List[Dict[str, str]], str]:
+            """Send message to chat."""
+            if not message:
+                return history, ""
+            history.append({"role": "user", "content": message})
+            response = chat_with_user(message, history, CHATBOT_SYSTEM_PROMPT)
             history.append({"role": "assistant", "content": response})
-            return history, "", ""
-            
-        def end_chat_with_status(history: List[Dict[str, str]], state: AppState) -> Tuple[List[str], gr.update, str]:
-            """End chat and extract keywords."""
-            if not history:
-                return [], gr.update(visible=True), ""
-            keywords = extract_keywords_from_conversation(history)
-            state.generated_keywords = keywords
-            return keywords, gr.update(visible=True), ""
-            
-        def export_with_status(df: pd.DataFrame) -> Tuple[str, str]:
-            """Export with status update."""
-            result = export_results(df)
-            return result, ""
-            
-        # Update event handlers with status updates
-        submit_btn.click(
-            fn=lambda: "Processing...",
-            inputs=[],
-            outputs=[submit_status]
-        ).then(
-            fn=process_repo_input_with_status,
-            inputs=[repo_id_input, state],
-            outputs=[df_output, submit_status]
-        )
+            return history, ""
         
-        def search_click():
-            """Handle search button click."""
-            return "Searching..."
-            
-        def search_complete(keyword: str, state: AppState):
-            """Complete search operation."""
-            return keyword_search_with_status(keyword, state)
-            
-        search_btn.click(
-            fn=search_click,
-            inputs=[],
-            outputs=[search_status]
-        ).then(
-            fn=search_complete,
-            inputs=[keyword_input, state],
-            outputs=[df_output, search_status]
-        )
+        def clear_chat() -> Tuple[List[Dict[str, str]], str]:
+            """Clear chat history."""
+            return [], ""
         
-        next_btn.click(
-            fn=lambda: "Analyzing...",
-            inputs=[],
-            outputs=[next_status]
-        ).then(
-            fn=analyze_with_status,
-            inputs=[state],
-            outputs=[content_output, summary_output, df_output, next_status]
+        # Event handlers
+        submit_btn.click(
+            fn=process_input,
+            inputs=[repo_input, state],
+            outputs=[df_output, status, content_output, summary_output]
         )
         
         send_btn.click(
-            fn=lambda: "Sending...",
-            inputs=[],
-            outputs=[send_status]
-        ).then(
-            fn=send_message_with_status,
+            fn=send_message,
             inputs=[msg, chatbot, state],
-            outputs=[chatbot, msg, send_status]
-        )
-        
-        end_chat_btn.click(
-            fn=lambda: "Processing...",
-            inputs=[],
-            outputs=[end_chat_status]
-        ).then(
-            fn=end_chat_with_status,
-            inputs=[chatbot, state],
-            outputs=[gr.Textbox(label="Extracted Keywords"), results_page, end_chat_status]
-        )
-        
-        export_btn.click(
-            fn=lambda: "Exporting...",
-            inputs=[],
-            outputs=[export_status]
-        ).then(
-            fn=export_with_status,
-            inputs=[results_df],
-            outputs=[gr.Textbox(label="Export Status"), export_status]
-        )
-        
-        restart_btn.click(
-            fn=lambda: (state.reset(), navigate_to("start")),
-            inputs=[state],
-            outputs=[start_page, input_page, analysis_page, chatbot_page, results_page]
-        )
-        
-        def update_progress(current: int, total: int) -> float:
-            """Update progress bar."""
-            return (current / total) * 100
-            
-        def export_results(df: pd.DataFrame) -> str:
-            """Export results to CSV."""
-            try:
-                filename = f"analysis_results_{pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')}.csv"
-                df.to_csv(filename, index=False)
-                return f"Results exported to {filename}"
-            except Exception as e:
-                return f"Error exporting results: {e}"
-            
-        def load_history() -> pd.DataFrame:
-            """Load analysis history."""
-            try:
-                return pd.read_csv("analysis_history.csv")
-            except:
-                return pd.DataFrame(columns=["Date", "Repositories", "Keywords", "Results"])
-            
-        def save_to_history(repos: List[str], keywords: List[str], results: pd.DataFrame) -> None:
-            """Save current analysis to history."""
-            try:
-                history_df = load_history()
-                new_row = {
-                    "Date": pd.Timestamp.now().strftime("%Y-%m-%d %H:%M:%S"),
-                    "Repositories": ", ".join(repos),
-                    "Keywords": ", ".join(keywords),
-                    "Results": results.to_json()
-                }
-                history_df = pd.concat([history_df, pd.DataFrame([new_row])], ignore_index=True)
-                history_df.to_csv("analysis_history.csv", index=False)
-            except Exception as e:
-                logger.error(f"Error saving to history: {e}")
-                
-        # Add new event handlers for new features
-        history_btn.click(
-            fn=lambda: (load_history(), navigate_to("history")),
-            inputs=[],
-            outputs=[history_df, start_page, input_page, analysis_page, chatbot_page, results_page, help_page, comparison_page, history_page]
+            outputs=[chatbot, msg]
         )
         
-        back_to_results_btn.click(
-            fn=lambda: navigate_to("results"),
+        clear_btn.click(
+            fn=clear_chat,
             inputs=[],
-            outputs=[start_page, input_page, analysis_page, chatbot_page, results_page, help_page, comparison_page, history_page]
-        )
-        
-        compare_btn.click(
-            fn=lambda: (update_repo_choices(state), navigate_to("comparison")),
-            inputs=[state],
-            outputs=[repo1_select, repo2_select, start_page, input_page, analysis_page, chatbot_page, results_page, help_page, comparison_page, history_page]
+            outputs=[chatbot, msg]
         )
-        
-        back_to_analysis_btn.click(
-            fn=lambda: navigate_to("analysis"),
-            inputs=[],
-            outputs=[start_page, input_page, analysis_page, chatbot_page, results_page, help_page, comparison_page, history_page]
-        )
-        
+    
     return app
 
-def update_repo_choices(state: AppState) -> Tuple[List[str], List[str]]:
-    """Update repository choices for comparison."""
-    choices = state.repo_ids
-    return choices, choices
-
 if __name__ == "__main__":
     app = create_ui()
     app.launch()