ajusted structure

.env.example

@@ -0,0 +1,6 @@
+DATABASE_URL="postgres..."
+AGENT_API_URL=https://run.blaxel.ai...
+BLAXEL_API_KEY=...
+MCP_SERVER_URL=https://mcp-1st-birthday-....hf.space/
+GOOGLE_API_KEY=...
+USE_SERVER_KEYS=True #if True, use server keys; if False, user input keys

.gitignore

@@ -0,0 +1,18 @@
+.eggs/
+dist/
+/bk/
+.vscode/
+*.pyc
+__pycache__/
+*.py[cod]
+*$py.class
+__tmp/*
+*.pyi
+.mypycache
+.ruff_cache
+node_modules
+backend/**/templates/
+README_TEMPLATE.md
+.env
+*.pem
+post.md

Dockerfile

@@ -0,0 +1,40 @@
+# Use Python 3.10 base image
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    git-lfs \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    cmake \
+    rsync \
+    libgl1 \
+    && rm -rf /var/lib/apt/lists/* \
+    && git lfs install
+
+# Copy requirements first (for better caching)
+COPY requirements.txt .
+
+# Fresh install of Gradio 6 as recommended by Gradio team
+# Install in a single command to avoid conflicts
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir "gradio[mcp,oauth]==5.50.0" && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 7860
+
+# Set environment variables
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+ENV GRADIO_SERVER_PORT=7860
+
+# Run the application
+CMD ["python", "app.py"]

Makefile

@@ -0,0 +1,10 @@
+check_dirs := config
+
+check:
+	ruff check $(check_dirs) app.py
+	ruff format --check $(check_dirs) app.py
+
+format:
+	ruff check $(check_dirs) app.py --fix
+	ruff format $(check_dirs) app.py
+	

README.md

@@ -1,8 +1,8 @@
 ---
-title: Gitrepo Inspector Dashboard
+title: GitRepo Inspector Dashboard
 emoji: 💻
-colorFrom: red
-colorTo: yellow
+colorFrom: gray
+colorTo: indigo
 sdk: docker
 pinned: false
 short_description: GitRepo Inspector Application Dashboard

app.py

@@ -0,0 +1,1200 @@
+import os
+import re
+import time
+import gradio as gr
+import markdown
+import pandas as pd
+import requests
+import services.db as db
+from dotenv import load_dotenv
+from gradio_client import Client
+from gradio_htmlplus import HTMLPlus
+from gradio_bottombar import BottomBar
+from gradio_buttonplus import ButtonPlus
+from services import charts
+from services.table_renderer import generate_issues_html
+from services.chat_utils import stream_to_gradio
+from services.agent_chat import create_dashboard_agent 
+from config.constants import AVAILABLE_MODELS_BY_PROVIDER
+
+load_dotenv()
+ACTIVE_SYNCS = set()
+DEFAULT_SORT = {"col": "updated_at", "asc": False}
+DEFAULT_REPO = "https://github.com/gradio-app/gradio"
+BLAXEL_ICON_URL = "https://huggingface.co/datasets/DEVAIEXP/assets/resolve/main/blaxel_logo.png"
+
+# Configuration
+MCP_SERVER_URL = os.getenv("MCP_SERVER_URL", "https://mcp-1st-birthday-gitrepo-inspector-mcp.hf.space/")
+AGENT_API_URL = os.getenv("AGENT_API_URL", "https://run.blaxel.ai/devaiexp/agents/agent")
+BLAXEL_API_KEY = os.getenv("BLAXEL_API_KEY")
+
+# LOGIC LAYER
+def _validate_api_keys(llm_api_key, request):
+    USE_SERVER_KEYS = os.getenv("USE_SERVER_KEYS", "false").lower() in (
+        "True",
+        "true",
+        "1",
+        "yes",
+    )
+    if not USE_SERVER_KEYS and request and request.headers.get("referer"):
+        if not llm_api_key or not llm_api_key.strip():
+            raise gr.Error("⚠️ LLM API Key Required! Please enter your own API Key to use this tool in the demo UI.")
+
+def _get_custom_header():
+    html = """
+    <style>
+        .header-container {           
+            background: linear-gradient(314deg, #64748b 0%, #373f4a 100%);
+            padding: 30px 20px;
+            border-radius: 16px;
+            color: white !important;
+            text-align: center;
+            box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+            margin-bottom: 25px;
+            font-family: 'Inter', -apple-system, sans-serif;
+        }
+        
+        .header-content {
+            max-width: 800px;
+            margin: 0 auto;
+        }
+
+        .header-title {
+            color: white !important;
+            font-size: 2.5rem;
+            font-weight: 800;
+            margin: 0;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 15px;
+            letter-spacing: -0.02em;
+            text-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        
+        .header-icon {
+            font-size: 3rem;
+            filter: drop-shadow(0 2px 4px rgba(0,0,0,0.1));
+        }
+
+        .header-subtitle {
+            color: var(--neutral-200) !important;
+            font-size: 1.1rem;
+            font-weight: 400;
+            margin-top: 8px;
+            opacity: 0.9;
+            letter-spacing: 0.01em;
+        }
+
+        .header-footer {
+            color: var(--neutral-200) !important;
+            margin-top: 25px;
+            padding-top: 15px;
+            border-top: 1px solid rgba(255, 255, 255, 0.2);
+            font-size: 0.85rem;
+            font-weight: 500;
+            opacity: 0.85;
+            display: flex;
+            justify-content: center;
+            flex-wrap: wrap;
+            gap: 15px;
+        }
+        
+        .header-tag {
+            color: var(--neutral-200) !important;
+            display: flex;
+            align-items: center;
+            gap: 6px;
+        }
+        
+        .separator {
+            color: var(--neutral-200) !important;
+            opacity: 0.4;
+        }
+        .header-img-icon {
+            width: 18px;
+            height: 18px;
+            vertical-align: text-bottom;            
+            opacity: 0.9;
+        }
+    </style>
+
+    <div class="header-container">
+        <div class="header-content">
+            <div class="header-title">
+                <span class="header-icon">🕵️‍♂️</span> GitRepo Inspector
+            </div>
+            <div class="header-subtitle">
+                Autonomous AI Agent for GitHub Issue Triage & Management
+            </div>
+            
+            <div class="header-footer">
+                <span class="header-tag">Powered by Gradio 🚀</span>
+                <span class="separator">|</span>
+                <span class="header-tag">
+                    Blaxel Agents 
+                    <img src="{BLAXEL_ICON_URL}" class="header-img-icon" alt="icon">
+                </span>
+                <span class="separator">|</span>
+                <span class="header-tag">MCP Protocol 🔌</span>
+                <span class="separator">|</span>
+                <span class="header-tag">Gemini • SambaNova • OpenAI • Nebius</span>
+            </div>
+        </div>
+    </div>
+    """
+    return html.replace("{BLAXEL_ICON_URL}", BLAXEL_ICON_URL)
+
+def _format_logs_to_html(logs_df):
+    """
+    Converts logs to HTML list with Icons and Client-side Timezone conversion.
+    """
+    if logs_df.empty:
+        return "<div style='color: #666; padding: 10px;'>Waiting for agent activity...</div>"
+        
+    html_content = """
+    <style>
+        .log-entry {
+            display: flex;
+            align-items: center;
+            padding: 4px 0;
+            border-bottom: 1px solid rgba(128,128,128, 0.1);
+            font-family: 'Consolas', monospace;
+            font-size: 12px;
+            color: var(--body-text-color);
+        }
+        .log-icon-img {
+            width: 20px;
+            height: 20px;
+            margin-right: 8px;
+            border-radius: 4px;
+        }
+        .log-time {
+            color: #6B7280;
+            margin-right: 10px;
+            min-width: 70px;
+            font-weight: bold;
+        }
+        .log-type { margin-right: 8px; }
+    </style>
+    <div id="log-container">
+    """
+    
+    for _, row in logs_df.iterrows():
+        # ISO timestamp for JS to read (e.g., 2023-11-22T10:00:00Z)
+        iso_time = row['created_at'].isoformat()
+        
+        etype = str(row['event_type']).lower()
+        icon_char = "🧠" if 'thought' in etype else "🔌" if 'tool' in etype else "❌" if 'error' in etype else "✅" if 'success' in etype else "ℹ️"
+        
+        issue_tag = f"<span style='color: #3B82F6;'>[#{int(row['issue_number'])}]</span> " if pd.notna(row['issue_number']) and row['issue_number'] != "None" else ""
+        
+        # Build HTML line
+        html_content += f"""
+        <div class="log-entry">
+            <img src="{BLAXEL_ICON_URL}" width=32 class="log-icon-img" alt="icon">
+            <!-- JS will fill this span with local time -->
+            <span class="log-time local-time" data-timestamp="{iso_time}">--:--:--</span>
+            <span class="log-type">{icon_char}</span>
+            <span>{issue_tag}{row['message']}</span>
+        </div>
+        """
+        
+    html_content += "</div>"    
+    
+    return html_content
+
+def fetch_fresh_data_to_cache(log_limit=50, repo_url=None):
+    """
+    Fetches all necessary data from DB.
+    """
+    stats_df = db.fetch_dashboard_stats(repo_url)
+    total_open = db.get_total_open_issues_count(repo_url)
+    donut_fig = charts.create_verdict_donut(stats_df)
+    funnel_fig = charts.create_efficiency_funnel(stats_df, total_open)
+    
+    logs_df = db.fetch_agent_logs(limit=log_limit)
+    logs_text = _format_logs_to_html(logs_df)
+    
+    full_df = db.fetch_issues_dataframe("all", repo_url) 
+    timeline_fig = charts.create_timeline_chart(full_df) 
+    
+    return donut_fig, funnel_fig, timeline_fig, full_df, logs_text
+
+def render_from_cache(df_cache, view_filter, sort_config, page=1):
+    if df_cache is None or df_cache.empty:
+        return generate_issues_html(pd.DataFrame()), "Page 1 / 1", 1
+
+    if "Action" in view_filter:
+        df = df_cache[
+            (df_cache['status'] == 'pending_approval') & 
+            (df_cache['proposed_action'].notnull())
+        ]
+    else:
+        df = df_cache
+
+    if sort_config and sort_config['col'] in df.columns:
+        df = df.sort_values(
+            by=sort_config['col'], 
+            ascending=sort_config['asc'], 
+            na_position='last'
+        )
+
+    total_rows = len(df)
+    total_pages = (total_rows // 50) + 1 if total_rows > 0 else 1
+    
+    page = max(1, min(page, total_pages))
+    
+    start = (page - 1) * 50
+    end = start + 50
+    
+    df_page = df.iloc[start:end]
+    
+    html = generate_issues_html(df_page, sort_config.get('col'), sort_config.get('asc'))
+    page_label = f"Page **{page}** of {total_pages} ({total_rows} items)"
+    
+    return html, page_label, page
+
+def refresh_dashboard_data(view_filter, sort_config=None, log_limit=50, repo_url=None):
+    if sort_config is None:
+        sort_config = DEFAULT_SORT
+        
+    donut_fig, timeline_fig, full_df, logs_text = fetch_fresh_data_to_cache(log_limit, repo_url)
+    
+    html_table, page_label, page = render_from_cache(full_df, view_filter, sort_config, 1)
+
+    return donut_fig, timeline_fig, html_table, logs_text, full_df, page_label, page
+
+def load_issue_details(issue_number, repo_url):
+    """
+    Loads details for an issue.
+    Strategy: Check Agent Cache -> Fallback to DB.
+    """
+    if not issue_number or issue_number == 0:
+        return gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip()
+    
+    body = None
+    action_json = None
+    status = "pending_approval"
+    thought_content = ""
+    wrapped_html = ""
+    
+    body, action_json, status, thought_process = db.fetch_issue_details_by_id(issue_number, repo_url)    
+    raw_body = body if body else "No content."
+    
+
+    if "<div" in raw_body and "Analyzed by" in raw_body:
+        final_html = raw_body.replace("```html", "").replace("```", "")
+    else:
+        final_html = markdown.markdown(raw_body, extensions=['tables', 'fenced_code'])
+        final_html = f"<h3 style='color:#4B5563; border-bottom:1px solid #eee; padding-bottom:5px;'>Analysis Report</h3>{final_html}"
+
+    wrapped_html = f"""
+    <div style="
+        font-family: -apple-system, system-ui, sans-serif; 
+        line-height: 1.6; 
+        color: var(--body-text-color);
+        padding: 20px; 
+        background: var(--background-fill-secondary);
+        border-radius: 8px; 
+        border: 1px solid var(--border-color-primary);
+        max-height: 600px;
+        overflow-y: auto;
+    ">
+        {final_html}
+    </div>
+    """
+
+    def get_summary_text(st, act):
+        if st == 'pending_approval':            
+            return f"### ⚠️ Action Required\n**Issue #{issue_number}** is marked as **{act.get('reason', 'resolved') if act else 'needs review'}**."
+        elif st == 'executed':
+            return f"### ✅ Action Executed\n**Issue #{issue_number}** was closed."
+        else:
+            return f"### ℹ️ Status: {st}"
+
+    has_thought = thought_process is not None and len(thought_process.strip()) > 0
+    thought_content = thought_process if has_thought else "No thought process available."
+        
+    summary_text = get_summary_text(status, action_json)
+        
+    if not body:
+        placeholder_html = f"""
+        <div style="
+            font-family: -apple-system, system-ui, sans-serif; 
+            color: #64748B; 
+            padding: 40px; 
+            text-align: center;
+            background: var(--background-fill-secondary);
+            border-radius: 8px; 
+            border: 1px dashed var(--border-color-primary);
+        ">
+            <h3>Waiting for Analysis ⏳</h3>
+            <p>This issue has not been processed by the Agent yet.</p>
+            <p>Click <b>'Analyze Now'</b> to start manual analysis.</p>
+        </div>
+        """
+        
+        return (
+            placeholder_html, 
+            gr.update(value="", interactive=False, label="No Proposal"), 
+            "", 
+            gr.update(visible=False),
+            gr.update(visible=True, interactive=True, value="▶️ Analyze Now"),
+            summary_text,
+            "", # Empty thought
+            gr.update(visible=True, open=True),
+            gr.update(visible=False, open=False)
+        )
+        
+    is_executed = (status == 'executed')
+    is_pending = (status == 'pending_approval')
+    
+    comment_val = action_json.get('comment', '') if action_json else ""
+    
+    comment_update = gr.update(
+        value=comment_val, 
+        interactive=is_pending, 
+        label="Executed Comment" if is_executed else "Proposed Comment"
+    )
+    
+    auth_vis = gr.update(visible=is_pending)
+    
+    reanalyze_vis = gr.update(visible=not is_executed, interactive=not is_executed, value="🔄 Re-Analyze Issue")
+    
+    return wrapped_html, comment_update, "", auth_vis, reanalyze_vis, summary_text, thought_content, gr.update(visible=True, open=True), gr.update(visible=has_thought, open=False)
+
+def trigger_sync_action(repo_url, user_token):
+    """
+    Calls the MCP sync tool for the selected repository.
+    """
+    if not repo_url:        
+        error = "Please select or type a repository URL."
+        gr.Info(f"⚠️ {error}")
+        return error        
+    
+    clean_url = repo_url.strip().rstrip("/")
+    
+    if not clean_url.startswith("https://github.com/"):
+        error = "Invalid URL. Must start with https://github.com/"
+        gr.Info(f"⚠️ {error}")
+        return error        
+            
+    if clean_url in ACTIVE_SYNCS:
+        error = "Sync already in progress for {clean_url}. Please wait..."
+        gr.Info(f"⚠️ {error}")
+        return error                
+            
+    if not user_token:
+        error = "GitHub Token Required!"
+        gr.Info(f"⚠️ {error}")
+        return error                        
+    
+    ACTIVE_SYNCS.add(clean_url)
+    try:
+        client = Client(MCP_SERVER_URL)
+       
+        job = client.submit(
+            repo_url,
+            user_token,
+            api_name="/sync_repository"
+        )
+       
+        for update in job:       
+            yield f"{update}"
+            
+    except Exception as e:
+        yield f"❌ Sync Failed: {str(e)}"
+    finally:
+        if clean_url in ACTIVE_SYNCS:
+            ACTIVE_SYNCS.remove(clean_url)
+
+def trigger_manual_reanalysis(issue_number, repo_url, provider, model, github_token, api_key, request: gr.Request = None):
+    """
+    Calls the Blaxel Agent to force a re-analysis.
+    """
+    if not issue_number:
+        error = "Select an issue first."
+        gr.Info(f"⚠️ {error}")
+        return error            
+        
+    _validate_api_keys(api_key, request)
+
+    if not AGENT_API_URL: 
+        error = "Agent URL not configured."
+        gr.Info(f"⚠️ {error}")
+        return error         
+    
+    payload = {
+        "repo_url": repo_url,
+        "provider": provider,
+        "model": model,
+        "specific_issue": int(issue_number),
+        "github_token": github_token if github_token else None
+    }
+    gr.Info(f"⏳ Starting analysis for #{issue_number}. Please wait...")
+    try:
+        headers = {"Authorization": f"Bearer {BLAXEL_API_KEY}", "Content-Type": "application/json"}        
+        with requests.post(AGENT_API_URL, json=payload, headers=headers, stream=True) as resp:
+            for _ in resp.iter_lines():
+                pass            
+            return f"✅ Analysis completed for #{issue_number}. Check the Trace Log tab for details."
+    except Exception as e:
+        return f"❌ Agent Trigger Failed: {e}"
+        
+def execute_approval_workflow(issue_number, repo_url, user_token, final_comment):
+    if not user_token:
+        error = "GitHub Token Required! Check Sidebar."
+        gr.Info(f"⚠️ {error}")
+        return error
+    
+    try:    
+        proposal = db.get_proposed_action_payload(issue_number, repo_url)        
+        # Flexible Logic:
+        # If proposal exists, use its 'close' flag.
+        # If NO proposal (user manual action), assume they want to close.
+        should_close = True 
+        if proposal:
+            should_close = proposal.get('action') == 'close'
+            
+        # If user didn't type comment, use proposal or default
+        if not final_comment:
+            if proposal:
+                final_comment = proposal.get('comment', "Closing via GitRepo Inspector.")
+            else:
+                final_comment = "Closing via GitRepo Inspector (Manual Action)."
+
+        client = Client(MCP_SERVER_URL)
+        result = client.predict(
+            repo_url,
+            int(issue_number),
+            final_comment,
+            should_close,
+            user_token,
+            api_name="/reply_and_close_issue"
+        )
+
+        db.update_issue_status(issue_number, repo_url, "executed", final_comment)
+                
+        return f"✅ Success: {result}"
+
+    except Exception as e:
+        # If it's a gr.Error, let it raise to show popup
+        if isinstance(e, gr.Error):
+            raise e
+        # If other error, format it
+        return f"❌ Error: {str(e)}"
+
+def generate_priority_report(repo_url, provider, model, api_key, request: gr.Request = None):
+    """
+    Generates priority report using Sidebar configs.
+    Handles tuple return (html, thought) from MCP.
+    """
+    gr.Info(f"🧠 Generating Strategy Report for {repo_url}... Please wait.")
+    llm_api_key = _validate_api_keys(api_key, request)
+
+    try:
+        client = Client(MCP_SERVER_URL)        
+        job = client.submit(
+            repo_url,
+            provider, 
+            model, 
+            llm_api_key,
+            api_name="/prioritize_open_issues"
+        )
+                
+        for tuple_result in job:
+            if isinstance(tuple_result, (list, tuple)) and len(tuple_result) > 0:
+                html_content = tuple_result[0]
+                yield html_content 
+            else:             
+                yield tuple_result
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+    
+def get_repo_choices():
+    repos = db.fetch_distinct_repos()
+    
+    if DEFAULT_REPO not in repos:
+        repos.insert(0, DEFAULT_REPO)
+    return repos
+
+# UI LAYOUT
+css_code = ""
+try:
+    with open("./style.css", "r", encoding="utf-8") as f:
+        css_code += f.read() + "\n"
+except FileNotFoundError:
+    pass
+
+# JS
+APP_HEAD = """
+<script>  
+    window.convert_timestamps = function() {
+        console.log("🕒 Converting timestamps...");
+        const spans = document.querySelectorAll('.local-time');
+        spans.forEach(span => {
+            const ts = span.getAttribute('data-timestamp');
+            if (ts) {
+                const date = new Date(ts);
+                span.innerText = date.toLocaleTimeString([], { hour12: false });
+            }
+        });
+    }
+    window.print_report = function() {
+        const report = document.getElementById('prio-report');
+        if (!report) return;
+        
+        // Get inner HTML content (within shadow DOM or Gradio div)
+        // Gradio 5 encapsulates, so we need to find real content
+        const content = report.querySelector('.prose') || report;
+        
+        const printWindow = window.open('', '', 'height=600,width=800');
+        printWindow.document.write('<html><head><title>Priority Report</title>');
+        printWindow.document.write('<style>body{font-family:sans-serif; padding:20px;} table{width:100%; border-collapse:collapse;} th,td{border:1px solid #ddd; padding:8px;}</style>');
+        printWindow.document.write('</head><body>');
+        printWindow.document.write(content.innerHTML);
+        printWindow.document.write('</body></html>');
+        printWindow.document.close();
+        printWindow.print();
+    }
+</script>
+"""
+
+theme = gr.themes.Default(
+    primary_hue='blue',
+    secondary_hue='teal',
+    neutral_hue='neutral'
+).set(
+    body_background_fill='*neutral_100',
+    body_background_fill_dark='*neutral_900',
+    body_text_color='*neutral_700',
+    body_text_color_dark='*neutral_200',
+    body_text_weight='400',
+    link_text_color='*primary_500',
+    link_text_color_dark='*primary_400',
+    code_background_fill='*neutral_100',
+    code_background_fill_dark='*neutral_800',
+    shadow_drop='0 1px 3px rgba(0,0,0,0.1)',
+    shadow_inset='inset 0 2px 4px rgba(0,0,0,0.05)',
+    block_background_fill='*neutral_50',
+    block_background_fill_dark='*neutral_700',
+    block_border_color='*neutral_200',
+    block_border_color_dark='*neutral_600',
+    block_border_width='1px',
+    block_border_width_dark='1px',
+    block_label_background_fill='*primary_50',
+    block_label_background_fill_dark='*primary_600',
+    block_label_text_color='*primary_600',
+    block_label_text_color_dark='*primary_50',
+    panel_background_fill='white',
+    panel_background_fill_dark='*neutral_800',
+    panel_border_color='*neutral_200',
+    panel_border_color_dark='*neutral_700',
+    panel_border_width='1px',
+    panel_border_width_dark='1px',
+    input_background_fill='white',
+    input_background_fill_dark='*neutral_800',
+    input_border_color='*neutral_300',
+    input_border_color_dark='*neutral_700',
+    slider_color='*primary_500',
+    slider_color_dark='*primary_400',
+    button_primary_background_fill='*primary_600',
+    button_primary_background_fill_dark='*primary_500',
+    button_primary_background_fill_hover='*primary_700',
+    button_primary_background_fill_hover_dark='*primary_400',
+    button_primary_border_color='transparent',
+    button_primary_border_color_dark='transparent',
+    button_primary_text_color='white',
+    button_primary_text_color_dark='white',
+    button_secondary_background_fill='*neutral_200',
+    button_secondary_background_fill_dark='*neutral_600',
+    button_secondary_background_fill_hover='*neutral_300',
+    button_secondary_background_fill_hover_dark='*neutral_500',
+    button_secondary_border_color='transparent',
+    button_secondary_border_color_dark='transparent',
+    button_secondary_text_color='*neutral_700',
+    button_secondary_text_color_dark='*neutral_200'
+)
+
+with gr.Blocks(title="GitRepo Inspector", theme=theme, css=css_code, head=APP_HEAD) as app:    
+    
+    # STATES
+    current_sort = gr.State(DEFAULT_SORT)
+    issues_cache = gr.State(pd.DataFrame())
+    current_page = gr.State(1)
+    sel_issue_state = gr.State()
+    sel_repo_state = gr.State()
+    agent_state = gr.State(value=None)
+    
+    with gr.Sidebar(position="left", open=True, label="Settings"):
+        gr.Markdown("### ⚙️ Configuration")
+        
+        # Repository Selection
+        repo_choices = get_repo_choices()
+        global_repo_url = gr.Dropdown(
+            elem_classes="custom-dropdown",
+            choices=repo_choices,
+            value=DEFAULT_REPO,
+            label="Repository",
+            allow_custom_value=True,
+            interactive=True,
+            info="Select existing or type new URL"
+        )
+        with gr.Row():
+            sync_repo_btn = ButtonPlus("🔄 Sync This Repo", help="Update Repository Issues Cache. This may take a while.")
+        sync_status = gr.Markdown(visible=True, value="Ready to sync.")
+        
+        global_github_token = gr.Textbox(
+            label="GitHub Personal Token", 
+            type="password", 
+            placeholder="ghp_...",
+            info="Required for 'Approve' and 'Prioritize'"
+        )
+        
+        gr.Markdown("---")
+        gr.Markdown("### 🧠 AI Model Configuration")
+        gr.Markdown("(For Manual Actions)")
+        
+        default_provider = "gemini"
+        global_provider = gr.Dropdown(
+            choices=list(AVAILABLE_MODELS_BY_PROVIDER.keys()), 
+            value=default_provider, 
+            label="LLM Provider"
+        )
+        
+        # Use default provider list
+        global_model = gr.Dropdown(
+            choices=AVAILABLE_MODELS_BY_PROVIDER[default_provider], 
+            value=AVAILABLE_MODELS_BY_PROVIDER[default_provider][0], 
+            label="Model Name",
+            allow_custom_value=True,
+            interactive=True
+        )
+        
+        global_llm_key = gr.Textbox(
+            label="LLM API Key", 
+            type="password", 
+            placeholder="your API Key...",
+            info="Required for approval and reanalysis actions"
+        )
+
+        gr.Markdown("---")
+        log_limit_slider = gr.Slider(
+            minimum=10, 
+            maximum=200, 
+            value=50, 
+            step=10, 
+            label="Log Lines to Fetch"
+        )
+    
+    gr.HTML(_get_custom_header())
+
+    # Control Bar
+    with gr.Row():      
+        with gr.Column(scale=1): 
+            pass 
+        with gr.Column(scale=0, min_width=150):
+            refresh_global = gr.Button("🔄 Refresh Data", variant="secondary")
+        
+    with gr.Sidebar(position="right", open=False, width=400):
+        with gr.Column(scale=1, elem_classes="column-container", min_width=400):
+            gr.Markdown("### 🤖 AI Assistant")
+            with gr.Column(scale=2):
+                chatbot = gr.Chatbot(
+                    elem_classes="chatbot-container",
+                    type="messages",
+                    height=500,
+                    show_label=False,
+                    show_copy_button=True,
+                    avatar_images=(
+                        "https://huggingface.co/datasets/DEVAIEXP/assets/resolve/main/user.png",
+                        "https://huggingface.co/datasets/DEVAIEXP/assets/resolve/main/gemini-icon.png"
+                    )
+                )
+            with gr.Row():
+                msg = gr.Textbox(label="Input Message", max_lines=2, scale=4, placeholder="Ask: 'What's up with issue #123?'")
+                send_btn = gr.Button("Send", variant="primary", scale=1)
+            with gr.Row():    
+                clear_chat_btn = gr.Button("🧹 Clear History")
+            
+            chat_trigger_issue = gr.Number(visible=False)
+            def clear_chat():
+                return []
+
+            clear_chat_btn.click(
+                fn=clear_chat,
+                inputs=None,
+                outputs=[chatbot]
+            )
+            def init_agent():
+                return create_dashboard_agent()
+        
+            def interact(agent, prompt, history, current_repo, provider, model, token):                
+                agent_state = agent
+                if agent_state is None:
+                    agent_state = init_agent()
+                    if agent_state is None:
+                        history.append(gr.ChatMessage(role="user", content=prompt, metadata={"status": "done"}))
+                        history.append(gr.ChatMessage(
+                            role="assistant",
+                            content="❌ Failed to initialize agent",
+                            metadata={"status": "done"}
+                        ))
+                        yield history, "", gr.skip(), agent_state
+                        return
+                    time.sleep(2)    
+                
+                context_prompt = f"""
+                    User is looking at repository: '{current_repo}'
+                    Selected analysis provider: '{provider}'
+                    Selected model: '{model}'
+                    GitHub Token provided: {'Yes' if token else 'No'}
+
+                    User Query: {prompt}
+                """
+                history.append(gr.ChatMessage(role="user", content=prompt))
+                yield history, "", gr.skip(), agent_state
+                
+                full_response = ""
+                detected_issue = gr.skip(), agent_state
+                
+                if agent_state:
+                    try:
+                        for chunk in stream_to_gradio(agent_state, context_prompt):
+                            if isinstance(chunk, gr.ChatMessage):
+                                history.append(chunk)
+                            elif isinstance(chunk, str):
+                                if history and history[-1].role == "assistant":
+                                    history[-1].content += chunk
+                                else:
+                                    history.append(gr.ChatMessage(role="assistant", content=chunk))
+                            
+                            content = chunk.content if isinstance(chunk, gr.ChatMessage) else chunk
+                            full_response += str(content)
+                            yield history, "", gr.skip(), agent_state
+                        
+                        # Check Trigger
+                        triggers = re.findall(r"\[VIEW:#(\d+)\]", full_response)            
+                        detected_issue = None
+                        if triggers:
+                            # Get the last mentioned (or first, your choice)
+                            # Usually the last is the conclusion focus
+                            detected_issue = int(triggers[-1]) 
+                                                        
+                            # Remove ALL [VIEW:#...] tags from final message
+                            last_msg = history[-1]
+                            
+                            if isinstance(last_msg, gr.ChatMessage):
+                                clean_content = re.sub(r"\[VIEW:#\d+\]", "", last_msg.content).strip()
+                                last_msg.content = clean_content
+                            elif isinstance(last_msg, dict):
+                                last_msg['content'] = re.sub(r"\[VIEW:#\d+\]", "", last_msg['content']).strip()
+                        
+                        yield history, "", detected_issue, agent_state
+                        
+                    except Exception as e:
+                        history.append(gr.ChatMessage(role="assistant", content=f"Error: {e}"))
+                        yield history, "", gr.skip(), agent_state
+                else:
+                    history.append(gr.ChatMessage(role="assistant", content="Agent failed to initialize."))
+                    yield history, "", gr.skip(), agent_state
+            
+            submit_event = gr.on(
+                triggers=[send_btn.click, msg.submit],
+                fn=interact, 
+                inputs=[
+                    agent_state, 
+                    msg,
+                    chatbot,
+                    global_repo_url,
+                    global_provider,
+                    global_model,
+                    global_github_token 
+                ], 
+                outputs=[chatbot, msg, chat_trigger_issue, agent_state],
+                show_progress="hidden"
+            )
+      
+    with gr.Row():
+        with gr.Column(scale=3, elem_classes="column-container"):                    
+            # MAIN CONTENT
+            with gr.Tabs():
+                with gr.TabItem("📋 Issues Overview"):
+                    with gr.Row():
+                        # Left: Table
+                        with gr.Column():
+                            view_filter = gr.Radio(
+                                ["Action Required", "All Issues"], 
+                                value="Action Required", 
+                                label="View Filter", 
+                                show_label=False, 
+                                container=False
+                            )
+                            html_table_output = HTMLPlus(
+                                label="Issue List", 
+                                selectable_elements=["th", "tr"]
+                            )
+                            with gr.Row(elem_id="pagination-row"):                                                        
+                                btn_prev = gr.Button("◀", elem_classes="pagination-btn", size="sm")                                                                
+                                page_display = gr.Markdown("Page 1 of 1", elem_id="page_label")                                
+                                btn_next = gr.Button("▶", elem_classes="pagination-btn", size="sm")
+                                 
+                    # Details & Action
+                    with gr.Group(visible=True):
+                        with gr.Accordion("📄 Issue Analysis Detail", open=False, visible=False) as issue_analysis_accordion:                        
+                            with gr.Row():                            
+                                with gr.Column(scale=3):
+                                    detail_view = gr.HTML(label="Full Report")
+                                    
+                                with gr.Column(scale=1, elem_classes="action-console-col"):
+                                    with gr.Group() as action_group:
+                                        gr.Markdown("#### ⚡ Action Console")
+                                        action_summary = gr.Markdown("Select an issue.")
+                                        action_comment_input = gr.Textbox(label="Proposed Comment", lines=3, interactive=True)
+                                        
+                                        reanalyze_btn = gr.Button("🔄 Re-Analyze Issue")
+                                        
+                                        with gr.Column(visible=False) as auth_box:
+                                            approve_btn = gr.Button("✅ Approve Action", variant="primary")
+                                        exec_status = gr.Markdown()
+                        with gr.Accordion("🧠 Agent Thought Process", open=False, visible=False) as thought_accordion:
+                            thought_view = gr.Markdown("Select an issue to see the reasoning.")
+                    gr.Markdown("---")
+                    # Charts
+                    gr.Markdown("### 📊 Analytics Overview")
+                    with gr.Row():
+                        with gr.Column():
+                            stats_plot = gr.Plot(label="Distribution", show_label=False)
+                        with gr.Column():
+                            funnel_plot = gr.Plot(label="Efficiency", show_label=False)
+                        with gr.Column():
+                            timeline_plot = gr.Plot(label="Timeline", show_label=False)
+                      
+                with gr.TabItem("🥇 Prioritize"):
+                    gr.Markdown("### Strategic Backlog Prioritization")
+                    with gr.Row():
+                        prio_btn = gr.Button("Generate Strategy Report 🧠", variant="primary")
+                        print_btn = gr.Button("🖨️ Print Report", variant="secondary") 
+                    with gr.Group():
+                        prio_out = gr.HTML(label="AI Strategy Report", elem_id="prio-report")
+            
+    # BOTTOM BAR
+    with BottomBar(label="🤖 AI Assistant", bring_to_front=False, height=320, open=False, rounded_borders=True):
+        gr.Markdown("### 📊 Workflow Agent Activity Logs", elem_id="logs-header")        
+        with gr.Row():
+            auto_refresh_timer = gr.Timer(value=30, active=True)
+            with gr.Column(scale=1):
+                refresh_interval = gr.Slider(
+                    info="Auto-refresh interval",
+                    minimum=30,
+                    maximum=300,
+                    value=30,
+                    step=30, 
+                    label="Auto-Refresh (seconds)",
+                    interactive=True,                
+                )            
+            with gr.Column(scale=6):
+                activity_log = gr.HTML(label="Trace Log", elem_id="trace-log")
+    
+    # EVENTS
+    trigger_outputs = [
+        detail_view, 
+        action_comment_input, 
+        exec_status, 
+        auth_box, 
+        reanalyze_btn, 
+        action_summary, 
+        thought_view,
+        issue_analysis_accordion,
+        thought_accordion,
+        chat_trigger_issue
+    ]
+    def handle_chat_view_trigger(issue_number, repo_url):
+        if not issue_number:
+            return tuple(gr.skip() for _ in range(len(trigger_outputs)))
+        
+        # Small pause to ensure DB write propagated
+        time.sleep(3)
+        
+        # Call function to load data, which will now find the record
+        details = load_issue_details(issue_number, repo_url)
+        return details + (None,)
+
+    chat_trigger_issue.change(
+        fn=handle_chat_view_trigger,
+        inputs=[chat_trigger_issue, global_repo_url],
+        outputs=trigger_outputs
+    )
+  
+    # Refresh Logic
+    def hard_refresh(filter_val, sort_val, log_lim, repo_url=None):    
+        repo = repo_url if repo_url else "https://github.com/gradio-app/gradio"
+        donut_fig, funnel_fig, timeline_fig, full_df, logs = fetch_fresh_data_to_cache(log_lim, repo)
+        html, label, page = render_from_cache(full_df, filter_val, sort_val, 1)
+    
+        return (
+            donut_fig,      # stats_plot
+            timeline_fig,   # timeline_plot
+            funnel_fig,     # funnel_plot
+            html,           # html_table_output
+            logs,           # activity_log
+            full_df,        # issues_cache
+            label,          # page_display
+            page,           # current_page
+    
+            "",             # detail_view
+            "Select an issue.", # action_summary
+            gr.update(visible=False), # auth_box
+            "",              # exec_status
+            gr.update(visible=False), # thought_accordion
+            gr.update(visible=False, open=False), # issue_analysis_accordion
+            ""              # thought_view
+        )
+
+    common_outputs = [
+        stats_plot, 
+        funnel_plot,
+        timeline_plot,
+        html_table_output,
+        activity_log, 
+        issues_cache, 
+        page_display,
+        current_page,
+        detail_view,
+        action_summary,
+        auth_box,
+        exec_status,
+        thought_accordion,
+        issue_analysis_accordion,
+        thought_view 
+    ]
+    
+    # Added log_limit_slider to inputs
+    app.load(
+         init_agent, 
+         outputs=[agent_state]
+    )
+    app.load(
+        fn=hard_refresh,
+        inputs=[view_filter, current_sort, log_limit_slider, global_repo_url],
+        outputs=common_outputs,
+        show_progress_on=[
+            html_table_output,
+            stats_plot, 
+            funnel_plot,
+            timeline_plot,
+        ]
+    ).success(
+        fn=None,
+        js="() => window.convert_timestamps()"
+    )
+    
+    refresh_global.click(
+        fn=hard_refresh,
+        inputs=[view_filter, current_sort, log_limit_slider, global_repo_url],
+        outputs=common_outputs,
+        show_progress_on=[
+            html_table_output,
+            stats_plot, 
+            funnel_plot,
+            timeline_plot,
+        ]
+    ).then(
+        fn=None,
+        js="() => window.convert_timestamps()"
+    )
+    def quick_log_refresh(log_lim):
+        df = db.fetch_agent_logs(limit=log_lim)
+        return _format_logs_to_html(df)
+
+    auto_refresh_timer.tick(
+        fn=quick_log_refresh,
+        inputs=[log_limit_slider],
+        outputs=[activity_log]
+    ).then(
+        fn=None,
+        js="() => window.convert_timestamps()"
+    )
+
+    # Update timer when slider changes
+    refresh_interval.change(
+        fn=lambda x: gr.Timer(value=x),
+        inputs=[refresh_interval],
+        outputs=[auto_refresh_timer]
+    )
+
+    def update_dashboard_models(provider):
+        models = AVAILABLE_MODELS_BY_PROVIDER.get(provider, [])
+        # Select first from list by default, or empty if none
+        new_val = models[0] if models else None
+        return gr.update(choices=models, value=new_val)
+
+    global_provider.change(
+        fn=update_dashboard_models,
+        inputs=[global_provider],
+        outputs=[global_model]
+    )
+    # Soft Updates
+    def soft_update(df, filter_val, sort_val):
+        html, label, page = render_from_cache(df, filter_val, sort_val, 1)
+        return html, label, page
+
+    view_filter.change(fn=soft_update, inputs=[issues_cache, view_filter, current_sort], outputs=[html_table_output, page_display, current_page])
+
+    def change_page(direction, current, df, filter_val, sort_val):
+        new_page = current + direction
+        html, label, final_page = render_from_cache(df, filter_val, sort_val, new_page)
+        return html, label, final_page
+
+    btn_prev.click(fn=lambda p, df, f, s: change_page(-1, p, df, f, s), inputs=[current_page, issues_cache, view_filter, current_sort], outputs=[html_table_output, page_display, current_page])
+    btn_next.click(fn=lambda p, df, f, s: change_page(1, p, df, f, s), inputs=[current_page, issues_cache, view_filter, current_sort], outputs=[html_table_output, page_display, current_page])
+
+    # Selection
+    def handle_table_interaction(evt: gr.SelectData, df_cache, view_filter, sort_data):
+        data = evt.value 
+        if evt.index == "th": 
+            clicked_col = data.get('sortCol') or data.get('sort-col')
+            if not clicked_col: return gr.skip() 
+            new_asc = not sort_data['asc'] if sort_data['col'] == clicked_col else False
+            new_sort = {"col": clicked_col, "asc": new_asc}
+            html, _, _ = render_from_cache(df_cache, view_filter, new_sort, page=1)
+            return (
+                new_sort, 
+                html,
+                gr.skip(),
+                gr.skip(),
+                gr.skip(), 
+                gr.skip(),
+                gr.skip(),
+                gr.skip(),
+                gr.skip(),
+                gr.skip(),
+                gr.skip(),
+                gr.skip(),
+                gr.skip(),
+            )
+        elif evt.index == "tr":            
+            issue_num = data.get('issueNumber') or data.get('issue-number')
+            repo_url = data.get('repoUrl') or data.get('repo-url')
+            if not issue_num: 
+                return gr.skip()
+            report, action_text, status, auth_vis, reanalyze_vis, summary_text, thought_text, issue_accordion, thought_accordion = load_issue_details(issue_num, repo_url)
+            
+            return (
+                gr.skip(),
+                gr.skip(),
+                report,
+                action_text,
+                auth_vis,
+                issue_num,
+                repo_url,
+                "",
+                reanalyze_vis,
+                thought_accordion,
+                issue_accordion,
+                summary_text,
+                thought_text 
+            )
+        return gr.skip()
+
+    html_table_output.select(
+        fn=handle_table_interaction, 
+        inputs=[issues_cache, view_filter, current_sort], 
+        outputs=[
+            current_sort,
+            html_table_output,
+            detail_view,
+            action_comment_input,
+            auth_box,
+            sel_issue_state,
+            sel_repo_state,
+            exec_status,
+            reanalyze_btn,
+            thought_accordion,
+            issue_analysis_accordion,
+            action_summary,
+            thought_view 
+        ],
+        show_progress_on=[issue_analysis_accordion]
+    )
+
+    # Actions
+    approve_btn.click(
+        fn=execute_approval_workflow,
+        inputs=[sel_issue_state, sel_repo_state, global_github_token, action_comment_input],
+        outputs=[exec_status]
+    ).success(
+        fn=hard_refresh,
+        inputs=[view_filter, current_sort, log_limit_slider, global_repo_url],
+        outputs=common_outputs,
+        show_progress_on=[
+            html_table_output,
+            stats_plot, 
+            funnel_plot,
+            timeline_plot,
+        ]
+    )
+
+    prio_btn.click(
+        fn=generate_priority_report,
+        inputs=[global_repo_url, global_provider, global_model, global_llm_key],
+        outputs=[prio_out],
+        show_progress="hidden"
+    )
+    print_btn.click(fn=None, js="() => window.print_report()")
+    global_repo_url.change(
+        fn=hard_refresh,
+        inputs=[view_filter, current_sort, log_limit_slider, global_repo_url],
+        outputs=common_outputs,
+        show_progress_on=[
+            html_table_output,
+            stats_plot, 
+            funnel_plot,
+            timeline_plot,
+        ]
+    )
+    # Sync Button Logic
+    sync_repo_btn.click(
+        fn=trigger_sync_action,
+        inputs=[global_repo_url, global_github_token],
+        outputs=[sync_status],
+        show_progress="hidden",
+        concurrency_limit=10
+    ).success(        
+        fn=hard_refresh,
+        inputs=[view_filter, current_sort, log_limit_slider, global_repo_url],
+        outputs=common_outputs,
+        show_progress_on=[
+            html_table_output,
+            stats_plot, 
+            funnel_plot,
+            timeline_plot,
+        ]
+    )
+    reanalyze_btn.click(
+        fn=trigger_manual_reanalysis,
+        inputs=[
+            sel_issue_state, 
+            sel_repo_state, 
+            global_provider, 
+            global_model, 
+            global_github_token,
+            global_llm_key
+        ],
+        outputs=[exec_status]
+    ).success(
+        fn=hard_refresh,
+        inputs=[view_filter, current_sort, log_limit_slider, global_repo_url],
+        outputs=common_outputs,
+        show_progress_on=[
+            html_table_output,
+            stats_plot, 
+            funnel_plot,
+            timeline_plot,
+        ]
+    )
+
+if __name__ == "__main__":
+    app.launch()

config/constants.py

@@ -0,0 +1,19 @@
+# General
+AVAILABLE_MODELS_BY_PROVIDER = {
+    "gemini": ["gemini-2.0-flash"],
+    "sambanova": [
+        "DeepSeek-R1",
+        "DeepSeek-V3-0324",
+        "DeepSeek-V3.1",
+        "Meta-Llama-3.1-8B-Instruct",
+        "Meta-Llama-3.3-70B-Instruct",
+        "gpt-oss-120b",
+    ],
+    "openai": ["gpt-4o-mini", "gpt-4o"],
+    "nebius": [
+        "deepseek-ai/DeepSeek-R1-0528",
+        "meta-llama/Llama-3.3-70B-Instruct",
+        "nvidia/Llama-3_1-Nemotron-Ultra-253B-v1",
+        "meta-llama/Meta-Llama-3.1-8B-Instruct-fast",
+    ],
+}

config/gitrepo_agent_prompt.yaml

@@ -0,0 +1,210 @@
+system_prompt: |-
+  You are the GitRepo Inspector Agent. Your goal is to answer questions about GitHub issues using the provided tools.
+
+  **CONTEXT & OVERRIDES:**
+  - The user has a default repository and LLM selected in the UI. This is your primary context.
+  - HOWEVER, if the user's prompt explicitly asks to use a DIFFERENT provider or model (e.g., "using OpenAI"), you MUST override the default from the context and use the one specified in the prompt.
+  - **Priority: Prompt > Context**.
+
+  **RULES:**
+  - You MUST start every step with `Thought:`.
+  - Then, write Python code in a ` ```python ... ``` ` block.
+  - Call one tool at a time.
+  - Finish your work by calling `final_answer("your text")`.
+
+  **TOOLS:**  
+  - `get_issue_status(issue_number, repo_url)`: Gets a pre-formatted AI report for a single issue.
+  - `search_issues(repo_url, author, verdict, query)`: Finds a LIST of issues.
+  - `trigger_live_analysis(issue_number, repo_url, github_token)`: Generate AI analysis report for a single issue.
+  - `web_search(query)`: Searches the web.
+
+  **DEFAULT REPO:**
+  If not specified, assume repo_url is `https://github.com/gradio-app/gradio`.
+
+  **UI CONTROL:**
+  - If your final answer is about ONE issue, append `[VIEW:#<issue_number>]` at the end of the text.
+
+  **MODEL-TO-PROVIDER MAPPING:**
+  - Gemini models: 'gemini-2.0-flash'
+  - OpenAI models: 'gpt-4o', 'gpt-4o-mini'
+  - Nebius models: 'deepseek-ai/DeepSeek-R1-0528', 'meta-llama/Llama-3.3-70B-Instruct', 'nvidia/Llama-3_1-Nemotron-Ultra-253B-v1", "meta-llama/Meta-Llama-3.1-8B-Instruct-fast'
+  - SambaNova models: 'DeepSeek-R1', 'DeepSeek-V3-0324', 'DeepSeek-V3.1', 'Meta-Llama-3.1-8B-Instruct', 'Meta-Llama-3.3-70B-Instruct', 'gpt-oss-120b'
+  
+  If a user specifies a model name, you MUST infer the correct provider from this map
+
+  **EXAMPLES:**
+  
+  ---
+  Task: "Which repository are we analyzing?"  
+  Thought: I know the context. I will answer directly using `final_answer`.
+  ```python
+  final_answer("We are currently analyzing the Gradio repository: https://github.com/gradio-app/gradio")
+  ```  
+  ---
+  
+  Task: "whats up with issue 123?"
+  Thought: The user wants to see everything about issue 123. I will get the report and trigger the UI to show the full details.
+  ```python
+  import re
+  report_text = get_issue_status(issue_number=123, repo_url="https://github.com/gradio-app/gradio")
+  
+  if "ERROR" in report_text:
+      final_answer(f"No report found for #123. Should I analyze it now?")
+  else:
+      verdict_match = re.search(r"VERDICT: (\w+)", report_text)
+      verdict = verdict_match.group(1) if verdict_match else "unknown"
+      final_answer(f"The verdict for issue #123 is **{verdict}**. I've opened the full report for you. [VIEW:#123]")
+  ```
+  
+  ---
+  Task: "What is the status of issue 456?"
+  Thought: The user just wants the status. I will get the report, extract only the verdict, and give a short answer without triggering the UI.
+  ```python
+  import re
+  report_text = get_issue_status(issue_number=456, repo_url="https://github.com/gradio-app/gradio")
+  
+  if "ERROR" in report_text:
+      final_answer("No analysis found in the database for issue #123")
+  else:
+      verdict_match = re.search(r"VERDICT: (\w+)", report_text)
+      verdict = verdict_match.group(1) if verdict_match else "unknown"
+      final_answer(f"The current AI-analyzed status for issue #456 is **{verdict}**.")
+  ```
+  
+  ---
+  Task: "Show me the full report for issue 123"  
+  Thought: The user wants to see the full report. I will use `get_issue_status` to get the data, but I only need to confirm it exists. The UI trigger will handle the display.
+  ```python
+  report_text = get_issue_status(issue_number=123, repo_url="https://github.com/gradio-app/gradio")
+  
+  if "ERROR" in report_text:
+      final_answer("I couldn't find a report for that issue.")
+  else:
+      final_answer(f"Opening full report for issue #123... [VIEW:#123]")
+  ```
+  
+  ---  
+  Task: "Why was issue #123 marked as duplicate?"
+  Thought: The user wants the justification for a duplicate. I need to get the report with `get_issue_status` and then use Python's `re` module to parse the "Justification:" text from the report.
+  ```python
+  import re
+  report_text = get_issue_status(issue_number=123, repo_url="https://github.com/gradio-app/gradio")
+  
+  if "duplicate" in report_text.lower():
+      justification_match = re.search(r"Justification:</strong>\s*(.*?)(</li>|<br>|\n)", report_text, re.DOTALL)
+      
+      if justification_match:
+          reason = justification_match.group(1).strip()
+          final_answer(f"It was marked as duplicate because: '{reason}'. [VIEW:#123]")
+      else:
+          final_answer("The report confirms it's a duplicate, but the specific reason was not found. [VIEW:#123]")
+  ```
+  
+  ---
+  Task: "Re-analyze issue #123 with OpenAI"  
+  Thought: The user wants to re-analyze with a specific provider. The context says the user selected 'openai' and 'gpt-4o-mini' in the UI. I will use the `trigger_live_analysis` tool and pass these parameters.
+  ```python
+  result = trigger_live_analysis(
+      issue_number=123,
+      repo_url="https://github.com/gradio-app/gradio",
+      provider="openai",
+      model="gpt-4o-mini"
+  )
+  final_answer(f"Re-analysis with OpenAI is complete. [VIEW:#123]")
+  ```
+  
+  ---
+  Task: "Analyze/Check issue #456 with Nebius"
+  Context: "Selected provider is 'gemini'"  
+  Thought: The user's prompt explicitly asks to use 'Nebius', which overrides the default 'gemini' from the context. I will call `trigger_live_analysis` with `provider='nebius'`.
+  ```python
+  result = trigger_live_analysis(
+      issue_number=456,
+      repo_url="https://github.com/gradio-app/gradio",
+      provider="nebius" # Override
+  )
+  final_answer(f"Analysis with Nebius is complete. [VIEW:#456]")
+  ```
+  
+  ---
+  Task: "Analyze/Check issue #456 with Nebius using the DeepSeek-R1 model"
+  Context: "Selected provider is 'gemini'"  
+  Thought: The user is overriding both the provider and the model. I must call `trigger_live_analysis` with `provider='nebius'` and `model='deepseek-ai/DeepSeek-R1'`.
+  ```python
+  result = trigger_live_analysis(
+      issue_number=456,
+      repo_url="https://github.com/gradio-app/gradio",
+      provider="nebius",
+      model="deepseek-ai/DeepSeek-R1-0528" # Override completo
+  )
+  final_answer(f"Analysis with Nebius (DeepSeek) is complete. [VIEW:#456]")
+  ```
+  
+  ---
+  Task: "Analyze/Check issue #789 with gpt-4o-mini"  
+  Thought: The user specified the model 'gpt-4o-mini'. According to my mapping, this model belongs to the 'openai' provider. I will call the tool with both parameters.
+  ```python
+  result = trigger_live_analysis(
+      issue_number=789,
+      repo_url="https://github.com/gradio-app/gradio",
+      provider="openai",  # I inferred this
+      model="gpt-4o-mini"
+  )
+  final_answer(f"Analysis with gpt-4o-mini is complete. [VIEW:#789]")
+  ```
+  
+  ---
+  Task: "Is issue #123 a duplicate? Check now."  
+  Thought: The user is asking for the status of a specific issue. I should first check the database using `get_issue_status` to see if we already have an analysis.
+  ```python
+  import re
+  report_text = get_issue_status(issue_number=123, repo_url="https://github.com/gradio-app/gradio")
+  
+  if "duplicate" in report_text.lower():
+      final_answer(f"Yes, my last analysis shows issue #123 is a duplicate. I've opened the report. [VIEW:#123]")
+  elif "ERROR" in report_text:
+      final_answer("I don't have a report for #123. Should I run a full analysis now?")
+  else:
+      verdict_match = re.search(r"VERDICT: (\w+)", report_text)
+      verdict = verdict_match.group(1) if verdict_match else "unknown"
+      final_answer(f"My last analysis for issue #123 shows a verdict of **{verdict}**, not duplicate. [VIEW:#123]")
+  ```
+  
+  ---
+  Task: "Find issues by abidlabs"
+  Thought: I need to search for multiple issues. I will use `search_issues`. It returns a formatted string list.
+  ```python
+  list_of_issues = search_issues(
+      repo_url="https://github.com/gradio-app/gradio",
+      author="abidlabs"
+  )
+  final_answer(list_of_issues)
+  ```
+
+planning:
+  initial_plan: |-
+    You are a planner. Given a task, create a simple plan.
+    Task: {{task}}
+    
+    1. Facts: What do I know? (Issue #, Repo)
+    2. Plan: Which tools to call?
+    
+    Write the plan and end with <end_plan>.
+
+  update_plan_pre_messages: |-
+    Update the plan based on progress.
+  
+  update_plan_post_messages: |-
+    Write the new plan and end with <end_plan>.
+
+managed_agent:
+  task: |-
+    You are a helper agent. Task: {{task}}
+  report: |-
+    {{final_answer}}
+
+final_answer:
+  pre_messages: |-
+    The agent has an answer.
+  post_messages: |-
+    {{task}}

pyproject.toml

@@ -0,0 +1,24 @@
+[tool.ruff]
+line-length = 160
+
+[tool.ruff.lint]
+# Never enforce `E501` (line length violations).
+ignore = ["C901", "E501", "E741", "F402", "F823"]
+select = ["C", "E", "F", "I", "W"]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+known-first-party = ["gitrepo_inspector_dashboard"]
+
+[tool.ruff.format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"

requirements.txt

@@ -0,0 +1,14 @@
+gradio
+sqlalchemy
+psycopg2-binary
+python-dotenv
+requests
+plotly
+markdown
+gradio_client
+gradio_htmlplus
+gradio_bottombar
+gradio_buttonplus
+smolagents>=1.22.0
+smolagents[mcp]>=1.22.0
+

services/agent_chat.py

@@ -0,0 +1,325 @@
+import os
+import re
+import markdown
+import yaml
+from dotenv import load_dotenv
+from smolagents import CodeAgent, LiteLLMModel, tool
+from smolagents.mcp_client import MCPClient as SmolMCPClient
+from gradio_client import Client as GradioClient
+from config.constants import AVAILABLE_MODELS_BY_PROVIDER
+from services.db import save_analysis_report
+
+load_dotenv()
+
+MCP_SERVER_URL = os.getenv("MCP_SERVER_URL", "https://mcp-1st-birthday-gitrepo-inspector-mcp.hf.space/")
+GEMINI_API_KEY = os.getenv("GOOGLE_API_KEY")
+
+class ModelFixerWrapper(LiteLLMModel):
+    """
+    Inherits from LiteLLMModel and overrides the `generate` method
+    to fix Gemini's common output formatting mistakes.
+    """
+    def generate(self, messages, **kwargs):
+        raw_chat_message = super().generate(messages, **kwargs)
+        raw_output = raw_chat_message.content if raw_chat_message.content else ""
+        
+        # 1. Try to find the code block
+        # Regex that searches for ```python ... ``` OR ``` ... ```
+        code_match = re.search(r"```(python)?\n(.*?)\n```", raw_output, re.DOTALL)
+        
+        if code_match:
+            # If found, ensure it's formatted correctly as ```python
+            code_content = code_match.group(2).strip()
+            fixed_code_block = f"```python\n{code_content}\n```"
+            
+            # Replace the original block with the corrected one
+            fixed_output = raw_output[:code_match.start()] + fixed_code_block + raw_output[code_match.end():]
+        else:
+            # If not found, don't modify
+            fixed_output = raw_output
+
+        # Ensure "Thought:"
+        if "```" in fixed_output and "Thought:" not in fixed_output:
+            fixed_output = "Thought: Executing.\n" + fixed_output
+        
+        raw_chat_message.content = fixed_output
+        return raw_chat_message
+
+    
+@tool
+def trigger_live_analysis(issue_number: int, repo_url: str, provider: str = "gemini", model: str = None, github_token: str = None) -> str:   
+    """
+    FORCES a NEW, LIVE analysis of an issue, ignoring any cached data.
+    Use this ONLY when the user explicitly asks to "re-analyze", "check again", "analyze now", or "run again".
+    Do NOT use this for simple status checks.
+    
+    Args:
+        issue_number: The issue number (e.g. 123).
+        repo_url: The full repository URL.
+        provider (str, optional): The AI provider name. Defaults to "gemini".
+        model (str, optional): The model identifier to use for analysis. 
+            Defaults to "gemini-2.0-flash".
+        github_token: Optional GitHub token for authentication.
+    """
+    try:
+        
+        if not model:            
+            models_for_provider = AVAILABLE_MODELS_BY_PROVIDER.get(provider.lower(), [])
+            if models_for_provider:
+                model = models_for_provider[0]
+            else:                
+                model = "gemini-2.0-flash" 
+                
+        # Use GradioClient directly for control over output format
+        client = GradioClient(MCP_SERVER_URL)
+        
+        # Call MCP Tool      
+        result = client.predict(
+            repo_url,
+            int(issue_number),
+            provider,
+            model,
+            github_token,            
+            None,
+            api_name="/analyze_github_issue"
+        )
+        
+        html_report = result[0]
+        thought = result[1]
+        
+        verdict = "unresolved" # Default
+        if "✅ Resolved" in html_report: verdict = "resolved"
+        elif "⚠️ Possibly Resolved" in html_report: verdict = "possibly_resolved"
+        elif "🔥 Duplicate" in html_report: verdict = "duplicate"
+        
+        try:
+            save_analysis_report(
+                repo_url=repo_url,
+                issue_number=int(issue_number),
+                provider=provider,
+                model=model,
+                verdict=verdict,
+                body=html_report,
+                thought=thought,
+                action=None,
+                priority=None
+            )
+            print(f"💾 Saved analysis for #{issue_number} to DB.")
+            
+           
+        except Exception as e:
+            print(f"⚠️ Failed to save report: {e}")
+            
+        # Clean HTML tags for LLM readability
+        clean_report = re.sub(r'<[^>]+>', '', html_report)
+        
+        return f"""
+        ANALYSIS COMPLETED.
+        
+        --- THINKING PROCESS ---
+        {thought}
+        
+        --- FINAL REPORT ---
+        {clean_report}
+        """
+    except Exception as e:
+        return f"Analysis failed: {e}"
+
+@tool
+def get_issue_status(issue_number: int, repo_url: str) -> str:
+    """
+    Retrieves the detailed AI analysis report for a SINGLE, SPECIFIC issue.
+    Use this when the user asks for "details", "status of", "what's up with" a specific issue number.
+    
+    Args:
+        issue_number: The specific issue number (e.g., 123).
+        repo_url: The full repository URL.
+    """
+    try:
+        client = GradioClient(MCP_SERVER_URL)
+       
+        result = client.predict(
+            repo_url, 
+            issue_number,
+            api_name="/get_issue_report"
+        )
+         
+        import json
+        if isinstance(result, str):
+            try:
+                data = json.loads(result)
+            except:         
+                return str(result)
+        elif isinstance(result, dict):
+            data = result
+        else:
+            return f"Unexpected format: {type(result)}"
+
+        if "error" in data and "No AI report found" in data['error']:
+            return f"ERROR: No analysis found in the database for issue #{issue_number}."
+       
+        if "error" in data:
+            return f"Status: Not Found\nDetails: {data['error']}"
+
+        body = data.get('report', '')
+        if "<div" in body and "Analyzed by" in body:
+            final_html = body.replace("```html", "").replace("```", "")
+        else:
+            final_html = markdown.markdown(body, extensions=['tables', 'fenced_code'])
+            final_html = f"<h3 style='color:#4B5563; border-bottom:1px solid #eee; padding-bottom:5px;'>Analysis Report</h3>{final_html}"
+
+        return f"""
+        --- ISSUE REPORT #{data.get('issue')} ---
+        VERDICT: {data.get('verdict')}
+        
+        --- ANALYSIS BODY ---
+        {data.get('report')}
+        
+        --- PROPOSED ACTION ---
+        {data.get('action')}
+        """
+
+    except Exception as e:
+        return f"Failed to fetch status: {e}"
+
+@tool
+def search_issues(
+    repo_url: str,
+    query: str = "",
+    issue_number: int = None,
+    status: str = "open",
+    verdict: str = None,
+    author: str = None,
+    limit: int = 5,    
+    state: str = None, 
+    max_results: int = None,
+    per_page: int = None
+) -> str:
+    """
+    Searches a LIST of issues based on KEYWORDS, author, or verdict.
+    Use this for BROAD questions like "Are there issues about...?" or "Find all issues by...".
+    DO NOT use this to get details of a single known issue number.
+    
+    Args:
+        repo_url: The full repository URL.
+        query: Text to search in title or body.
+        issue_number: Specific issue ID to find.
+        status: GitHub state ('open', 'closed'). Default: 'open'.
+        verdict: AI Analysis Verdict ('resolved', 'duplicate', 'unresolved').
+        author: Filter by issue author.
+        limit: Max results to return. Default: 5.
+        state: Alias for status parameter.
+        max_results: Alias for limit parameter.
+        per_page: Alias for limit parameter.
+    """
+    
+    final_status = state if state else status
+    final_limit = max_results if max_results else (per_page if per_page else limit)
+    
+    try:
+        client = GradioClient(MCP_SERVER_URL)
+        result = client.predict(
+            repo_url, 
+            query, 
+            issue_number, 
+            final_status, 
+            verdict, 
+            author,
+            final_limit,
+            api_name="/search_issues"
+        )
+    
+        import json
+        if isinstance(result, str):
+            try:
+                data = json.loads(result)
+            except:
+                return f"Error parsing JSON from MCP: {result}"
+        else:
+            data = result
+    
+        if not data:
+            return "No issues found matching criteria."
+        if isinstance(data, dict) and "error" in data:
+            return f"Search Error: {data['error']}"
+        if isinstance(data, str):
+            return data
+               
+        output = f"Found {len(data)} issues:\n"
+        for item in data:       
+            if not isinstance(item, dict): continue
+            
+            i_id = item.get('id', '?')
+            i_title = item.get('title', 'No Title')
+            i_author = item.get('author', 'Unknown')
+            i_verdict = item.get('verdict', 'pending')
+            i_snippet = item.get('snippet', '')[:100].replace('\n', ' ')
+            
+            output += f"- #{i_id} '{i_title}' (by @{i_author}) [Verdict: {i_verdict}]\n"
+            output += f"  Snippet: {i_snippet}...\n"
+            
+        return output
+
+    except Exception as e:
+        return f"Search tool failed: {str(e)}"
+
+def create_dashboard_agent():
+    if not GEMINI_API_KEY:
+        print("⚠️ Warning: GOOGLE_API_KEY not found.")
+
+    try:
+        print(f"🚀 Initializing Agent...")
+        yaml_path = os.path.join(os.path.dirname(__file__), "../config/gitrepo_agent_prompt.yaml")
+        
+        with open(yaml_path, 'r', encoding='utf-8') as f:
+            prompt_templates = yaml.safe_load(f)
+            
+        model = ModelFixerWrapper(
+            model_id="gemini/gemini-2.0-flash",
+            api_key=GEMINI_API_KEY,
+            temperature=0.2
+        )
+        
+        # 1. Import Automatic Tools from MCP (Search, WebSearch, etc.)
+        # Ensure URL ends with /gradio_api/mcp/sse for smolagents discovery
+        sse_url = f"{MCP_SERVER_URL.rstrip('/')}/gradio_api/mcp/sse"
+        mcp_client = SmolMCPClient({"url":sse_url, "transport":"sse"})
+        auto_tools = mcp_client.get_tools()
+        
+        # 2. Filter out tools we want to override
+        # Remove 'analyze_github_issue' to use our 'trigger_live_analysis' wrapper
+        # Remove 'get_issue_report' if we want to force usage of 'get_issue_status' wrapper
+        filtered_tools = [
+            t for t in auto_tools 
+            if t.name not in ['analyze_github_issue', 
+                              'search_issues', 
+                              'get_issue_report',
+                              'generate_sketch_to_ui', 
+                              'generate_theme'
+                            ]
+        ]
+        
+        # 3. Combine: Auto Tools + Custom Wrappers
+        final_tools = filtered_tools + [trigger_live_analysis, get_issue_status, search_issues]
+
+        # 4. Create Agent
+        agent = CodeAgent(
+            tools=final_tools,
+            model=model,
+            prompt_templates=prompt_templates,
+            additional_authorized_imports=["json", "re", "time", "datetime", "ast"],
+            add_base_tools=False,
+            max_steps=8,
+            planning_interval=3           
+        )
+        if agent:
+            print(f"Agent initialized successfully!")
+        else:
+            print(f"Agent not initialized!")
+        return agent
+
+    except Exception as e:
+        print(f"❌ Error creating agent: {e}")
+        import traceback
+        traceback.print_exc()
+        return None

services/charts.py

@@ -0,0 +1,183 @@
+import plotly.graph_objects as go
+import pandas as pd
+
+def create_verdict_donut(df: pd.DataFrame) -> go.Figure:
+    """
+    Creates a High-Fidelity Donut Chart.
+    """
+    if df.empty:
+        return _create_empty_figure("No Data")
+    
+    color_map = {
+        'resolved': '#10B981',          # Emerald 500
+        'possibly_resolved': '#34D399', # Emerald 400
+        'duplicate': '#F59E0B',         # Amber 500
+        'unresolved': '#64748B',        # Slate 500
+        'error': '#EF4444',             # Red 500
+        'unknown': '#CBD5E1'            # Slate 300
+    }
+    
+    colors = [color_map.get(v, '#999') for v in df['verdict']]
+    total = df['count'].sum()
+
+    fig = go.Figure(data=[go.Pie(
+        labels=df['verdict'],
+        values=df['count'],
+        hole=0.7,              
+        marker=dict(colors=colors, line=dict(color='#1F2937', width=0)),         
+        textinfo='value',
+        hoverinfo='label+percent',
+        textfont=dict(size=14, color='white')
+    )])
+
+    fig.update_layout(        
+        title=dict(
+            text="Analysis Distribution", 
+            font=dict(size=14, color="#6B7280"),
+            x=0.5,
+            xanchor='center'
+        ),
+        
+        showlegend=True,
+        legend=dict(
+            orientation="h", 
+            yanchor="top", 
+            y=-0.1,
+            xanchor="center", 
+            x=0.5,
+            font=dict(color="#9CA3AF", size=11)
+        ),
+                
+        margin=dict(t=40, b=60, l=20, r=20),
+        height=250,
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+                
+        annotations=[dict(text=str(total), x=0.5, y=0.5, font_size=32, showarrow=False, font_color="#E5E7EB")],
+                
+        modebar_remove=['zoom', 'pan', 'select', 'lasso2d', 'zoomIn2d', 'zoomOut2d', 'autoScale2d', 'resetScale2d', 'toImage']
+    )
+
+    return fig
+
+def create_timeline_chart(full_df: pd.DataFrame) -> go.Figure:
+    """
+    Creates a Timeline showing activity over time.
+    """
+    if full_df.empty:
+        return _create_empty_figure("No Timeline Data")
+
+    df = full_df.copy()
+    
+    df['date'] = pd.to_datetime(df['updated_at'], errors='coerce').dt.date
+    daily_counts = df.groupby('date').size().reset_index(name='count')
+    
+    fig = go.Figure()
+
+    fig.add_trace(go.Scatter(
+        x=daily_counts['date'],
+        y=daily_counts['count'],
+        mode='lines+markers',
+        name='Activity',
+        line=dict(color='#3B82F6', width=2, shape='spline'),
+        marker=dict(size=4, color='#60A5FA', line=dict(width=0)),
+        fill='tozeroy',
+        fillcolor='rgba(59, 130, 246, 0.1)'
+    ))
+
+    fig.update_layout(    
+        title=dict(
+            text="Activity Timeline (Last Updates)", 
+            font=dict(size=14, color="#6B7280"),
+            x=0.5,
+            xanchor='center'
+        ),
+        xaxis=dict(
+            showgrid=False, 
+            color="#9CA3AF",
+            gridcolor="rgba(255,255,255,0.1)",
+            tickformat="%b %d"
+        ),
+        yaxis=dict(
+            showgrid=True, 
+            gridcolor="rgba(255,255,255,0.05)", 
+            color="#9CA3AF",
+            zeroline=False
+        ),
+        margin=dict(t=40, b=20, l=30, r=10),
+        height=250,
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        showlegend=False,
+                
+        modebar_remove=['zoom', 'pan', 'select', 'lasso2d', 'zoomIn2d', 'zoomOut2d', 'autoScale2d', 'resetScale2d', 'toImage']
+    )
+
+    return fig
+
+def _create_empty_figure(text):
+    fig = go.Figure()
+    fig.add_annotation(text=text, showarrow=False, font=dict(color="gray"))
+    fig.update_layout(
+        height=250,
+        paper_bgcolor='rgba(0,0,0,0)', 
+        plot_bgcolor='rgba(0,0,0,0)', 
+        xaxis=dict(visible=False), 
+        yaxis=dict(visible=False),
+        modebar_remove=['zoom', 'pan', 'select', 'lasso2d', 'zoomIn2d', 'zoomOut2d', 'autoScale2d', 'resetScale2d', 'toImage']
+    )
+    return fig
+
+def create_efficiency_funnel(stats_df: pd.DataFrame, total_open_issues: int) -> go.Figure:
+    """
+    Creates a Funnel Chart showing how the AI filters the noise.
+    """
+    if stats_df.empty:
+        return _create_empty_figure("No Data")
+
+    total_backlog = total_open_issues
+    total_analyzed = stats_df['count'].sum()
+    
+    ai_solved = stats_df[stats_df['verdict'].isin(['resolved', 'duplicate', 'possibly_resolved'])]['count'].sum()
+    
+    
+    values = [total_backlog, total_analyzed, ai_solved]
+    stages = ["Total Backlog", "Analyzed by AI", "Actionable Findings"]
+    
+    fig = go.Figure(go.Funnel(
+        y=stages,
+        x=values,
+        textinfo="value+percent initial",
+                
+        textfont=dict(color="#e5e5e5", size=12),         
+        marker=dict(color=["#64748B", "#4486F0", "#10B981"]), 
+        connector=dict(line=dict(color="rgba(128,128,128,0.5)", width=1))
+    ))
+
+    fig.update_layout(
+        title=dict(
+            text="AI Efficiency Funnel", 
+            font=dict(size=14, color="#6B7280"),
+            x=0.5, xanchor='center'
+        ),
+        xaxis=dict(
+            showgrid=False, 
+            color="#9CA3AF",
+            gridcolor="rgba(255,255,255,0.1)",
+            tickformat="%b %d"
+        ),
+        yaxis=dict(
+            showgrid=True, 
+            gridcolor="rgba(255,255,255,0.1)", 
+            color="#9CA3AF",
+            zeroline=False
+        ),
+        margin=dict(t=40, b=20, l=100, r=10),
+        height=250,        
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        showlegend=False,
+        modebar_remove=['pan', 'select', 'lasso2d', 'autoScale2d', 'resetScale2d']
+    )
+
+    return fig

services/chat_utils.py

@@ -0,0 +1,134 @@
+import gradio as gr
+import re
+from smolagents.memory import ActionStep, PlanningStep, FinalAnswerStep
+from smolagents.models import ChatMessageStreamDelta
+
+def get_step_footnote_content(step_log: ActionStep | PlanningStep, step_name: str) -> str:
+    """Get a footnote string for a step log with duration and token information"""
+    step_footnote = f"**{step_name}**"
+    if hasattr(step_log, 'token_usage') and step_log.token_usage is not None:
+        step_footnote += f" | Input tokens: {step_log.token_usage.input_tokens:,} | Output tokens: {step_log.token_usage.output_tokens:,}"
+    if hasattr(step_log, 'timing') and step_log.timing and step_log.timing.duration:
+        step_footnote += f" | Duration: {round(float(step_log.timing.duration), 2)}s"
+    return f"""<span style="color: #bbbbc2; font-size: 12px;">{step_footnote}</span> """
+
+def _clean_model_output(model_output: str) -> str:
+    if not model_output:
+        return ""
+    model_output = model_output.strip()        
+    model_output = re.sub(r"```\s*<end_code>", "```", model_output)
+    model_output = re.sub(r"<end_code>\s*```", "```", model_output)
+    model_output = re.sub(r"```\s*\n\s*<end_code>", "```", model_output)    
+    return model_output
+
+def _process_action_step(step_log: ActionStep, skip_model_outputs: bool = False):
+    step_number = f"Step {step_log.step_number}"
+
+    if not skip_model_outputs and getattr(step_log, "model_output", ""):
+        model_output = _clean_model_output(step_log.model_output)
+        yield gr.ChatMessage(
+            role="assistant",
+            content=model_output,
+            metadata={"title": f"💭 Reasoning ({step_number})", "status": "done"}
+        )
+
+    if getattr(step_log, "tool_calls", []):
+        first_tool_call = step_log.tool_calls[0]
+        args = first_tool_call.arguments
+        content = str(args.get("answer", str(args))) if isinstance(args, dict) else str(args).strip()        
+        tool_name = first_tool_call.name
+        icon = "🔍" if "search" in tool_name else "🛠️"
+        
+        yield gr.ChatMessage(
+            role="assistant",
+            content=f"```python\n{content}\n```",
+            metadata={"title": f"{icon} Used tool: {tool_name}", "status": "done"}
+        )
+
+    if getattr(step_log, "observations", "") and step_log.observations.strip():
+        log_content = step_log.observations.strip()
+        yield gr.ChatMessage(
+            role="assistant",
+            content=f"```text\n{log_content}\n```",
+            metadata={"title": "📋 Tool Output", "status": "done"}
+        )
+
+    if getattr(step_log, "error", None):
+        yield gr.ChatMessage(
+            role="assistant", 
+            content=f"⚠️ **Error:** {str(step_log.error)}", 
+            metadata={"title": "🚫 Error", "status": "done"}
+        )
+
+    yield gr.ChatMessage(
+        role="assistant", 
+        content=get_step_footnote_content(step_log, step_number), 
+        metadata={"status": "done"}
+    )
+    yield gr.ChatMessage(role="assistant", content="---", metadata={"status": "done"})
+
+def _process_planning_step(step_log: PlanningStep, skip_model_outputs: bool = False):
+    if not skip_model_outputs:
+        yield gr.ChatMessage(
+            role="assistant",
+            content=step_log.plan,        
+            metadata={"title": "🧠 Planning Phase", "status": "done"} 
+        )
+
+    yield gr.ChatMessage(
+        role="assistant", 
+        content=get_step_footnote_content(step_log, "Planning Stats"), 
+        metadata={"status": "done"}
+    )
+    yield gr.ChatMessage(role="assistant", content="---", metadata={"status": "done"})
+    
+
+def _process_final_answer_step(step_log: FinalAnswerStep):
+    """
+    Extracts the final answer from the step log, handling multiple possible attributes.
+    """
+    final_answer = None
+
+    possible_attrs = ['output', 'answer', 'final_answer']
+    
+    for attr in possible_attrs:
+        if hasattr(step_log, attr):
+            final_answer = getattr(step_log, attr)
+            if final_answer:
+                break
+    
+    if final_answer is None:
+        final_answer = str(step_log)    
+        match = re.search(r"output=(['\"])(.*?)\1\)", final_answer, re.DOTALL)
+        if match:
+            final_answer = match.group(2).encode('utf-8').decode('unicode_escape')
+    
+    content = final_answer
+    if hasattr(content, 'to_string'):
+        content = content.to_string()
+    else:
+        content = str(content)
+
+    yield gr.ChatMessage(
+        role="assistant",
+        content=f"📜 **Final Answer**\n\n{content}",
+        metadata={"status": "done"}
+    )
+def pull_messages_from_step(step_log, skip_model_outputs=False):
+    if isinstance(step_log, PlanningStep):
+        yield from _process_planning_step(step_log, skip_model_outputs)
+    elif isinstance(step_log, ActionStep):
+        yield from _process_action_step(step_log, skip_model_outputs)
+    elif isinstance(step_log, FinalAnswerStep):
+        yield from _process_final_answer_step(step_log)
+
+def stream_to_gradio(agent, task: str, reset_agent_memory: bool = False):
+    """Main generator function for the Chat Interface"""
+   
+    for event in agent.run(task, stream=True, max_steps=10, reset=reset_agent_memory):
+        if isinstance(event, (ActionStep, PlanningStep, FinalAnswerStep)):
+            for message in pull_messages_from_step(event):
+                yield message
+        elif isinstance(event, ChatMessageStreamDelta):
+            if event.content:
+                yield event.content

services/db.py

@@ -0,0 +1,291 @@
+import os
+import json
+import psycopg2
+import pandas as pd
+from sqlalchemy import create_engine
+
+RAW_DB_URL = os.getenv("DATABASE_URL")
+
+# SQLAlchemy Configuration (Protocol fix for newer versions: postgres:// -> postgresql://)
+SQLALCHEMY_DB_URL = RAW_DB_URL.replace("postgres://", "postgresql://") if RAW_DB_URL else None
+
+# --- SQLALCHEMY SETUP (For Pandas Read Operations) ---
+try:
+    if not SQLALCHEMY_DB_URL:
+        raise ValueError("DATABASE_URL is not set in environment.")
+    
+    # Create global engine for connection pooling
+    db_engine = create_engine(SQLALCHEMY_DB_URL)
+    print("✅ SQLAlchemy Engine initialized.")
+except Exception as e:
+    print(f"❌ Error creating engine: {e}")
+    db_engine = None
+
+# --- PSYCOPG2 SETUP (For Write Operations) ---
+def get_raw_connection():
+    """
+    Creates a raw psycopg2 connection.
+    Used for UPDATE/INSERT operations where Pandas overhead is not needed.
+    """
+    if not RAW_DB_URL:
+        raise ValueError("DATABASE_URL is not set.")
+    return psycopg2.connect(RAW_DB_URL)
+
+# ==============================================================================
+#  READ OPERATIONS (Using SQLAlchemy + Pandas)
+#  Note: Pandas manages the connection opening/closing automatically via the engine.
+# ==============================================================================
+
+def fetch_distinct_repos():
+    """
+    Fetches a list of unique repository URLs present in the 'items' table.
+    Used to populate the repository selection dropdown in the Dashboard.
+    """
+    try:
+        # We query 'items' because it contains the raw synced data
+        query = "SELECT DISTINCT repo FROM items ORDER BY repo"
+        df = pd.read_sql(query, db_engine)
+        
+        slugs = df['repo'].tolist()
+        
+        # Transform slugs (owner/repo) into Full URLs
+        urls = [f"https://github.com/{slug}" for slug in slugs]
+        return urls
+    except Exception as e:
+        print(f"Error fetching repos: {e}")
+        return []
+
+def fetch_dashboard_stats(repo_url=None):
+    """
+    Calculates aggregate statistics (Total, Resolved, etc.), optionally filtered by repository.
+    Returns a DataFrame for the Donut Chart.
+    """
+    try:
+        query = "SELECT verdict, count(*) as count FROM issue_reports"
+        params = []
+        
+        if repo_url:
+            # Handle potential trailing slashes for exact matching
+            clean_url = repo_url.rstrip('/')
+            query += " WHERE (repo_url = %s OR repo_url = %s)"
+            params.extend([clean_url, clean_url + '/'])
+            
+        query += " GROUP BY verdict"
+        
+        return pd.read_sql(query, db_engine, params=tuple(params))
+    except Exception as e:
+        print(f"Stats Error: {e}")
+        return pd.DataFrame(columns=['verdict', 'count'])
+
+def fetch_issues_dataframe(view_filter="pending", repo_url=None):
+    """
+    Fetches the main list of issues for the table.
+    Performs a LEFT JOIN between 'items' (GitHub Data) and 'issue_reports' (AI Analysis).
+    """
+    try:
+        # Base Query: Retrieves everything from 'items' and attaches report data if available
+        base_query = """
+            SELECT 
+                i.number as issue_number,
+                i.title,
+                i.state as github_state,
+                -- URL: Use report URL if exists, otherwise construct from slug
+                COALESCE(r.repo_url, 'https://github.com/' || i.repo) as repo_url,
+                
+                -- Verdict: Default to 'Pending Analysis' if null
+                COALESCE(r.verdict, 'Pending Analysis') as verdict,
+                r.llm_model, 
+                r.confidence, 
+                r.priority, 
+                
+                -- Status: Default to 'new' if null
+                COALESCE(r.status, 'new') as status,
+                r.proposed_action,
+                
+                -- Date: Use analysis date if available, else GitHub update date
+                COALESCE(r.updated_at, i.updated_at) as updated_at
+            FROM items i
+            -- Soft Join: Match issue number AND ensure repo matches (via slug check)
+            LEFT JOIN issue_reports r 
+                ON i.number = r.issue_number 
+                AND r.repo_url ILIKE '%%' || i.repo || '%%'
+            WHERE (i.state = 'open' OR r.status = 'executed') AND i.is_pr = FALSE
+        """
+        
+        params = []
+        
+        # Apply Repo Filter (Filtering the 'items' table via slug)
+        if repo_url:
+            # Convert full URL to slug (e.g. "https://github.com/user/repo" -> "user/repo")
+            slug = repo_url.replace("https://github.com/", "").replace("http://github.com/", "").strip("/")
+            base_query += " AND i.repo = %s"
+            params.append(slug)
+        
+        # Apply View Filter
+        if "Action" in view_filter or "pending" in view_filter:
+            # Show only issues waiting for approval
+            base_query += " AND r.status = 'pending_approval' AND r.proposed_action IS NOT NULL ORDER BY r.updated_at DESC"
+        else:
+            # Show all issues (limit for performance)
+            base_query += " ORDER BY i.number DESC LIMIT 1000"
+            
+        return pd.read_sql(base_query, db_engine, params=tuple(params))
+    
+    except Exception as e:
+        print(f"Dataframe Error: {e}")
+        return pd.DataFrame()
+
+def get_total_open_issues_count(repo_url=None) -> int:
+    """
+    Counts the total number of open issues in the raw items table.
+    Used for the top of the Efficiency Funnel chart.
+    """
+    try:
+        query = "SELECT count(*) as total FROM items WHERE state = 'open'"
+        params = []
+        
+        if repo_url:
+            slug = repo_url.replace("https://github.com/", "").strip("/")
+            query += " AND repo = %s"
+            params.append(slug)
+            
+        df = pd.read_sql(query, db_engine, params=tuple(params))
+        
+        if not df.empty:
+            return int(df.iloc[0]['total'])
+        return 0
+        
+    except Exception as e:
+        print(f"Error counting open issues: {e}")
+        return 0
+
+def fetch_agent_logs(limit=20):
+    """
+    Fetches the latest activity logs from the agent_traces table.
+    """
+    try:
+        query = f"SELECT created_at, event_type, message, issue_number FROM agent_traces ORDER BY created_at DESC LIMIT {limit}"
+        return pd.read_sql(query, db_engine)
+    except Exception as e:
+        print(f"Logs Error: {e}")
+        return pd.DataFrame()
+
+# ==============================================================================
+#  WRITE OPERATIONS (Using Psycopg2 Raw Connection)
+#  Requires manual cursor management and connection closing.
+# ==============================================================================
+
+def fetch_issue_details_by_id(issue_number, repo_url):
+    """
+    Fetches the full markdown report, proposed action, and status for a specific issue.
+    Used when clicking a row in the table.
+    """
+    conn = get_raw_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute(
+            "SELECT analysis_body, proposed_action, status, thought_process FROM issue_reports WHERE issue_number = %s AND repo_url = %s",
+            (issue_number, repo_url)
+        )
+        row = cursor.fetchone()
+        return row if row else (None, None, None, None)
+    except Exception as e:
+        print(f"Error fetching details: {e}")
+        return (None, None, None, None)
+    finally:
+        cursor.close()
+        conn.close()
+
+def get_proposed_action_payload(issue_number, repo_url):
+    """
+    Retrieves the JSON action payload for execution.
+    """
+    conn = get_raw_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute(
+            "SELECT proposed_action FROM issue_reports WHERE issue_number = %s AND repo_url = %s",
+            (issue_number, repo_url)
+        )
+        row = cursor.fetchone()
+        return row[0] if row else None
+    except Exception as e:
+        print(f"Error fetching action: {e}")
+        return None
+    finally:
+        cursor.close()
+        conn.close()
+
+def update_issue_status(issue_number, repo_url, new_status, final_comment=None):
+    """
+    Updates status and optionally saves the final comment used.
+    """
+    conn = get_raw_connection()
+    cursor = conn.cursor()
+    try:
+        if final_comment is not None:
+            cursor.execute(
+                """
+                UPDATE issue_reports 
+                SET status = %s, 
+                    proposed_action = jsonb_set(COALESCE(proposed_action, '{}'), '{comment}', to_jsonb(%s::text))
+                WHERE issue_number = %s AND repo_url = %s
+                """,
+                (new_status, final_comment, issue_number, repo_url)
+            )
+        else:
+            cursor.execute(
+                "UPDATE issue_reports SET status = %s WHERE issue_number = %s AND repo_url = %s",
+                (new_status, issue_number, repo_url)
+            )
+        conn.commit()
+    except Exception as e:
+        print(f"Error updating status: {e}")
+    finally:
+        cursor.close()
+        conn.close()
+
+def save_analysis_report(
+    repo_url: str,
+    issue_number: int,
+    provider: str,
+    model: str,
+    verdict: str,
+    body: str,
+    thought: str = None,
+    action: dict = None,
+    priority: str = None,
+    duplicate_of: int = None
+):
+    """
+    Saves or updates an analysis report in the database.
+    Used by the Dashboard Chatbot when performing manual re-analysis.
+    """
+    conn = get_raw_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute(
+            """
+            INSERT INTO issue_reports (repo_url, issue_number, llm_provider, llm_model, verdict, analysis_body, thought_process, proposed_action, priority, duplicate_of, updated_at, status)
+            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, NOW(), 'pending_approval')
+            ON CONFLICT (repo_url, issue_number)
+            DO UPDATE SET
+                llm_provider = EXCLUDED.llm_provider,
+                llm_model = EXCLUDED.llm_model,
+                verdict = EXCLUDED.verdict,
+                analysis_body = EXCLUDED.analysis_body,
+                thought_process = EXCLUDED.thought_process,
+                proposed_action = EXCLUDED.proposed_action,
+                priority = EXCLUDED.priority,
+                duplicate_of = EXCLUDED.duplicate_of,
+                status = 'pending_approval',
+                updated_at = NOW();
+        """,
+            (repo_url, issue_number, provider, model, verdict, body, thought, json.dumps(action) if action else None, priority, duplicate_of),
+        )
+        conn.commit()
+    except Exception as e:
+        print(f"Error saving report: {e}")
+    finally:
+        cursor.close()
+        conn.close()

services/table_renderer.py

@@ -0,0 +1,230 @@
+import pandas as pd
+
+def get_verdict_badge(verdict, status, github_state):
+    v = str(verdict).lower()
+    # Badges use solid colors and white text, work well in both modes
+    if status == 'executed' or github_state == 'closed':
+        return '<span style="background-color: #374151; color: white; padding: 4px 8px; border-radius: 12px; font-size: 10px; font-weight: 600;">CLOSED</span>'
+    elif "possibly_resolved" in v:
+        return '<span style="background-color: #84CC16; color: white; padding: 4px 8px; border-radius: 12px; font-size: 10px; font-weight: 600; white-space: nowrap;">POSSIBLY RESOLVED</span>'
+    elif "unresolved" in v:
+        return '<span style="background-color: #64748B; color: white; padding: 4px 8px; border-radius: 12px; font-size: 10px; font-weight: 600;">OPEN BUG</span>'
+    elif "resolved" in v:
+        return '<span style="background-color: #10B981; color: white; padding: 4px 8px; border-radius: 12px; font-size: 10px; font-weight: 600;">RESOLVED</span>'
+    elif "duplicate" in v:
+        return '<span style="background-color: #F59E0B; color: white; padding: 4px 8px; border-radius: 12px; font-size: 10px; font-weight: 600;">DUPLICATE</span>'
+    elif "pending" in v or "new" in v:
+        # Adjusted for dark mode: darker background if needed, but light gray usually works
+        return '<span style="background-color: #94A3B8; color: white; padding: 3px 7px; border-radius: 12px; font-size: 10px; font-weight: 500; white-space: nowrap;">WAITING AGENT</span>'
+    else:
+        return f'<span style="background-color: #475569; color: white; padding: 4px 8px; border-radius: 12px; font-size: 10px;">{verdict}</span>'
+
+def get_priority_badge(priority):
+    p = str(priority).lower() if priority else ""
+    # Using text colors, they should contrast well on gradio's dark/light background
+    if "critical" in p: return '<span style="color: #EF4444; font-weight: 700;">🔥 Critical</span>'
+    if "high" in p: return '<span style="color: #F97316; font-weight: 600;">High</span>'
+    if "medium" in p: return '<span style="color: #3B82F6;">Medium</span>'
+    if "low" in p: return '<span style="color: #9CA3AF;">Low</span>'
+    return "-"
+
+def generate_issues_html(df: pd.DataFrame, sort_col: str = "updated_at", sort_asc: bool = False) -> str:
+    if df.empty:
+        # Using a white container even when empty to maintain consistency
+        return """
+        <div style='padding: 40px; text-align: center; color: var(--body-text-color); background: var(--background-fill-primary); border-radius: 12px; border: 1px solid #E2E8F0; font-family: sans-serif;'>
+            No issues found for this view.
+        </div>
+        """
+
+    headers_map = {
+        "Issue": "issue_number",
+        "Title / Repo": "title",
+        "Verdict": "verdict",
+        #"Priority": "priority",
+        "Model": "llm_model",
+        #"Confidence": "confidence",
+        "Updated": "updated_at"
+    }
+    
+    html = """
+    <style>
+        .tm-table-container { 
+            background-color: var(--background-fill-primary) !important; 
+            border: 0px solid var(--border-color-primary) !important; 
+            border-radius: 6px; 
+            max-height: 500px; 
+            overflow-y: auto; 
+            position: relative;
+            font-family: 'Inter', sans-serif;
+        }
+        
+        .tm-table { 
+            width: 100%; 
+            border-collapse: collapse; 
+            border-spacing: 0; 
+            border: none !important; /* Remove table border */
+            background-color: transparent !important;
+            color: var(--body-text-color) !important;            
+        }
+        
+        /* HEADER */
+        .tm-table thead th { 
+            position: sticky; 
+            top: 0; 
+            background: linear-gradient(135deg, var(--primary-600) 0%, var(--primary-500) 100%) !important;
+            color: #FFFFFF !important;
+            z-index: 10;
+            padding: 14px 16px; 
+            text-align: left; 
+            font-weight: 600; 
+            text-transform: uppercase; 
+            font-size: 11px; 
+            letter-spacing: 0.05em;
+            border: none !important; /* Remove header bottom border */
+            box-sizing: content-box !important; /* Requested adjustment */
+        }
+
+        /* ROWS */
+        .tm-table tbody tr { 
+            background-color: var(--background-fill-primary) !important;
+            border: none !important; /* Remove border between rows */
+            cursor: pointer; 
+            transition: all 0.15s; 
+            box-sizing: content-box !important; /* Requested adjustment */
+        }
+
+        /* Zebra Striping (Essential now that there are no borders) */
+        .tm-table tbody tr:nth-child(even) {
+            background-color: var(--background-fill-secondary) !important;
+        }
+
+        /* Hover */
+        .tm-table tbody tr:hover { 
+            background-color: var(--background-fill-secondary) !important;
+            filter: brightness(1.1); /* Subtle highlight */
+        }
+
+        /* CELLS */
+        .tm-table td { 
+            padding: 14px 16px; 
+            color: var(--body-text-color) !important; 
+            font-size: 13px; 
+            vertical-align: middle;
+            border: none !important; /* Ensure no borders in cells */
+        }
+
+        /* Typography */
+        .tm-title-text {
+            font-weight: 600;
+            color: var(--body-text-color) !important;
+            font-size: 14px;
+        }
+        .tm-subtext {
+            font-size: 11px;
+            color: var(--body-text-color-subdued) !important;
+            margin-top: 2px;
+        }
+        
+        /* Sort Icons */
+        .tm-sortable { cursor: pointer; }
+        .tm-sort-icon { display: inline-block; margin-left: 6px; font-size: 9px; color: rgba(255,255,255,0.7) !important; }
+        .tm-sort-active { color: #FFFFFF !important; }
+       
+        /* Status (Keep only the left border for indication) */
+        .status-pending { border-left: 4px solid #F59E0B !important; }
+        .status-executed { border-left: 4px solid #10B981 !important; }
+        .status-new { border-left: 4px solid transparent !important; }
+       
+        /* View Button */
+        a.tm-view-btn {
+            background-color: transparent !important;
+            color: #3B82F6 !important;
+            border: 1px solid #3B82F6 !important;
+            padding: 5px 10px; 
+            border-radius: 20px;
+            font-size: 10px; 
+            font-weight: 700; 
+            text-transform: uppercase; 
+            text-decoration: none;
+            display: inline-block; 
+            transition: all 0.2s;
+        }
+        a.tm-view-btn:hover {
+            background-color: #3B82F6 !important;
+            color: #FFFFFF !important;
+        }
+    </style>
+    
+    <div class="tm-table-container">
+        <table class="tm-table">
+            <thead>
+                <tr>
+    """
+
+    # Loop Headers
+    for display, col_name in headers_map.items():
+        width = 'style="width: 70px;"' if display == "Issue" else ""
+        
+        icon = ""
+        if col_name == sort_col:
+            icon = "▲" if sort_asc else "▼"
+            icon_class = "tm-sort-icon tm-sort-active"
+        else:
+            icon = "▼" # Default hint
+            icon_class = "tm-sort-icon"
+            
+        html += f"""
+            <th class="tm-sortable" {width} data-sort-col="{col_name}" title="Sort by {display}">
+                {display} <span class="{icon_class}">{icon}</span>
+            </th>
+        """
+    
+    html += """
+            <th style="width: 90px; text-align: center;">Actions</th>
+        </tr>
+    </thead>
+    <tbody>
+    """
+
+    for _, row in df.iterrows():
+        issue_num = row['issue_number']
+        repo_full = str(row['repo_url'])
+        repo_short = repo_full.split('github.com/')[-1] if 'github.com' in repo_full else repo_full
+        
+        title = str(row.get('title') or "No Title")
+        verdict_html = get_verdict_badge(row['verdict'], row['status'], row.get('github_state'))
+        #priority_html = get_priority_badge(row.get('priority'))
+        
+        raw_model = str(row.get('llm_model') or "")
+        model = raw_model.split('/')[-1] if raw_model else "-"
+        
+        #conf = f"{float(row.get('confidence', 0))*100:.0f}%" if row.get('confidence') else "-"
+        
+        # Define border class based on status
+        status_code = row.get('status', 'new')
+        status_class = f"status-{status_code}" if status_code in ['pending_approval', 'executed'] else "status-new"
+        
+        data_attrs = f'data-issue-number="{issue_num}" data-repo-url="{row["repo_url"]}" data-verdict="{row["verdict"]}"'
+        target_url = f"{repo_full.rstrip('/')}/issues/{issue_num}"
+
+        html += f"""
+            <tr class="{status_class}" {data_attrs}>
+                <td style="font-family: 'Monaco', monospace; font-weight: 600; color: #475569;">#{issue_num}</td>
+                <td>
+                    <div class="tm-title-text">{title[:65]}{'...' if len(title)>65 else ''}</div>
+                    <div class="tm-subtext">{repo_short}</div>
+                </td>
+                <td>{verdict_html}</td>                
+                <td class="tm-subtext">{model}</td>                
+                <td class="tm-subtext">{str(row["updated_at"])[:10]}</td>
+                <td style="text-align: center;">
+                    <a href="{target_url}" target="_blank" class="tm-view-btn" onclick="event.stopPropagation()">
+                        GitHub ↗
+                    </a>
+                </td>
+            </tr>
+        """
+
+    html += "</tbody></table></div>"
+    return html

style.css

@@ -0,0 +1,242 @@
+/* ==========================================================================
+   1. GLOBAL & LAYOUT STYLES
+   ========================================================================== */
+
+body {
+    font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
+    margin: 0;
+    padding: 0;
+}
+
+/* Main application container styling */
+.gradio-container {
+    border-radius: 15px;
+    padding: 10px 20px; 
+    box-shadow: 0 8px 30px rgba(0, 0, 0, 0.3); 
+    margin: 10px;
+}
+.column-container {
+    border-radius: 15px;
+    padding: 15px; 
+    box-shadow: 0 8px 30px rgba(0, 0, 0, 0.3); 
+    margin: auto;    
+}
+
+.action-console-col {
+    padding: 10px !important;
+    border-color: var(--border-color-primary) !important;
+    border-width: 1px !important;
+    border-radius: 8px;
+    margin-top: 10px;
+}
+.chatbot-container .message-row{
+    max-width: calc(100% - var(--spacing-sm) * 6) !important;
+}
+.chatbot-container pre code {
+    text-wrap: auto !important;
+}
+/* 2. Media Query for larger screens (desktops) */
+@media (min-width: 1281px) {
+    .gradio-container {        
+        padding: 10px 370px;
+        max-width: 2400px;
+    }
+}
+
+/* Text shadow for main headings for better readability */
+.gradio-container h1 {
+    text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.2);
+}
+
+/* Utility class to make elements fill their container's width */
+/* .fillable {
+    width: 100% !important;
+    max-width: unset !important; 
+} */
+#trace-log {
+    height: 200px !important;
+    overflow-y: auto !important;
+    background-color: var(--background-fill-primary);
+    border: 1px solid var(--border-color-primary);
+    border-radius: 8px;
+    padding: 10px;
+}
+.fillable .sidebar-parent {
+    padding-left: 10px !important;
+    padding-right: 10px !important;
+}
+
+
+/* ==========================================================================
+   2. CUSTOM SCROLLBAR STYLES (GLOBAL & SIDEBAR)
+   ========================================================================== */
+
+/* --- For WebKit browsers (Chrome, Safari, Edge, etc.) --- */
+.sidebar-content::-webkit-scrollbar,
+body::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+  background-color: transparent;
+}
+
+.sidebar-content::-webkit-scrollbar-track,
+body::-webkit-scrollbar-track {
+  background: transparent;
+  border-radius: 10px;
+}
+
+.sidebar-content::-webkit-scrollbar-thumb,
+body::-webkit-scrollbar-thumb {
+  background-color: rgba(136, 136, 136, 0.4);
+  border-radius: 10px;
+  border: 2px solid transparent;
+  background-clip: content-box;
+}
+
+.sidebar-content::-webkit-scrollbar-thumb:hover,
+body::-webkit-scrollbar-thumb:hover {
+  background-color: rgba(136, 136, 136, 0.7);
+}
+
+/* --- For Firefox --- */
+.sidebar-content,
+html {
+  scrollbar-width: thin;
+  scrollbar-color: rgba(136, 136, 136, 0.7) transparent;
+}
+
+
+/* ==========================================================================
+   3. SIDEBAR STYLES
+   ========================================================================== */
+
+.sidebar {
+    border-radius: 10px;
+    padding: 10px;
+    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.2);
+}
+
+/* Overrides for the content padding inside the sidebar */
+.sidebar .sidebar-content {
+    padding-left: 10px !important;
+    padding-right: 10px !important;
+}
+
+/* Centers text within Markdown blocks inside the sidebar */
+/* .sidebar .sidebar-content .column .block div .prose {
+    text-align: center;
+} */
+
+/* Stylish override for the sidebar toggle button */
+.sidebar .toggle-button {    
+    background: linear-gradient(135deg, var(--primary-500), var(--primary-600)) !important;
+    border: none;
+    padding: 12px 18px;
+    text-transform: uppercase;
+    font-weight: bold;
+    letter-spacing: 1px;
+    /* border-radius: 5px; */
+    position: absolute;
+    top: 50%;        
+    right: -28px !important;
+    left: auto !important;
+    transform: unset !important;   
+    border-radius: 0 var(--radius-lg) var(--radius-lg) 0 !important
+}
+
+.sidebar.right .toggle-button {
+    left: -28px !important;
+    right: auto !important; 
+    transform: rotate(180deg) !important;
+}
+
+.sidebar.open .chevron-left {
+    transform: rotate(-135deg);
+}
+
+.bottom-bar .toggle-bottom-button {
+    background: linear-gradient(135deg, var(--primary-500), var(--primary-600)) !important;
+}
+   
+.toggle-button:hover {
+    transform: scale(1.05);
+} 
+.bottom-bar .toggle-bottom-button .chevron {
+    width: 100%;
+    height: 100%;
+    position: relative;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.bottom-bar .toggle-bottom-button .chevron-arrow {    
+    position: relative !important;
+    top: auto !important;
+    left: auto !important;        
+    width: 10px !important;
+    height: 10px !important;
+    border-bottom: 2px solid var(--body-text-color) !important;
+    border-right: 2px solid var(--body-text-color) !important;    
+    transform: rotate(-135deg) translateY(2px);
+    margin-bottom: -4px;
+}
+.bottom-bar.open .chevron-arrow {
+    transform: rotate(45deg) translateY(-2px) !important;
+}
+
+/* ==========================================================================
+   5. COMPONENT-SPECIFIC STYLES & OVERRIDES
+   ========================================================================== */
+
+/* Custom styling for the cancel button */
+#cancel-button { /* Corrected the typo from 'cancell' to 'cancel' */
+    background: linear-gradient(120deg, var(--neutral-500) 0%, var(--neutral-600) 60%, var(--neutral-700) 100%) !important;
+}
+.custom-dropdown .wrap-inner input {
+    padding-right: 22px;
+}
+
+#pagination-row {
+    display: flex !important;
+    justify-content: center !important;
+    align-items: center !important;
+    gap: 4px !important;
+    margin-top: 8px !important;
+    padding: 0 !important;
+    min-height: 0 !important;
+    background: transparent !important;
+    border: none !important;
+}
+
+.pagination-btn {
+    width: 28px !important;
+    height: 28px !important;
+    min-width: 28px !important;
+    padding: 0 !important;
+    display: flex !important;
+    align-items: center !important;
+    justify-content: center !important;
+    font-size: 12px !important;
+    line-height: 1 !important;
+    border-radius: 4px !important;
+    flex-grow: 0 !important;
+    box-shadow: none !important;
+}
+
+#page_label {
+    flex: 0 0 auto !important;
+    width: auto !important;
+    display: inline-block !important;
+    margin: 0 8px !important;
+    font-size: 11px !important;
+    font-family: monospace !important;
+    white-space: nowrap !important;
+    color: var(--body-text-color-subdued);
+}
+
+#page_label p {
+    margin: 0 !important;
+    padding: 0 !important;
+    display: inline !important;
+}