app.py

import gradio as gr
import os
from pathlib import Path
import subprocess
import requests
import json
from datetime import datetime
import textwrap
import google.generativeai as genai
import asyncio
from typing import Generator, AsyncGenerator
from openai import AsyncOpenAI
import dotenv

# Load environment variables
dotenv.load_dotenv()

# Metadata
CURRENT_TIME = "2025-05-23 12:57:22"
CURRENT_USER = "ErRickow"

# Default API Keys (fallback if user doesn't provide their own)
DEFAULT_XAI_KEY = os.getenv("XAI_API_KEY", "xai-vfjhklL384Z4HKdItsZomqpFlXubTZJAFnISQUpV7dE8lRnWwYBVPSCxSTlu08wDbAcv720bx2dDiQ9x")
DEFAULT_GEMINI_KEY = os.getenv("GEMINI_API_KEY")

# API settings
OLLAMA_API = os.environ.get("OLLAMA_API", "http://localhost:11434")
XAI_BASE_URL = "https://api.x.ai/v1"

# Model lists
OLLAMA_MODELS = [
    "llama2",
    "codellama",
    "mistral",
    "neural-chat",
    "starling-lm",
    "dolphin-phi",
    "phi",
    "orca-mini"
]

XAI_MODELS = [
    "grok-2-latest",
    "grok-1",
]

GEMINI_MODELS = [
    "gemini-1.5-mini",
    "gemini-pro-vision",
]

# Help texts
XAI_API_HELP = """
### Cara Mendapatkan X.AI (Grok) API Key:

1. Kunjungi [X.AI Developer Portal](https://x.ai)
2. Daftar/Login ke akun Anda
3. Buat API Key baru
4. Salin API Key

Note:
- Jika tidak diisi, akan menggunakan API key default
- Masukkan API key Anda sendiri jika default mencapai limit
"""

class AIProvider:
    OLLAMA = "ollama"
    GEMINI = "gemini"
    XAI = "xai"

class RepoAnalyzer:
    def __init__(self):
        self.current_repo = None
        self.repo_content = {}
        self.chat_history = []

    async def stream_xai_response(self, prompt: str, api_key: str = None, model: str = "grok-2-latest") -> AsyncGenerator[str, None]:
        """Stream response dari X.AI (Grok) API"""
        try:
            # Use default key if none provided
            actual_key = api_key if api_key else DEFAULT_XAI_KEY
            
            if not actual_key:
                yield "⚠️ API Key X.AI diperlukan. Gunakan key Anda sendiri atau tunggu reset limit default key."
                return

            client = AsyncOpenAI(
                api_key=actual_key,
                base_url=XAI_BASE_URL
            )

            # Prepare messages with repository context if available
            messages = [
                {"role": "system", "content": "Anda adalah asisten AI yang membantu menganalisis repository code. Berikan respons dalam Bahasa Indonesia."}
            ]
            
            if self.current_repo:
                context = f"Repository: {self.current_repo}\n\n"
                repo_files = "\n".join(list(self.repo_content.keys()))
                context += f"Files in repository:\n{repo_files}\n\n"
                messages.append({"role": "system", "content": context})

            messages.append({"role": "user", "content": prompt})

            stream = await client.chat.completions.create(
                model=model,
                messages=messages,
                stream=True
            )

            full_response = ""
            async for chunk in stream:
                if chunk.choices[0].delta.content:
                    content = chunk.choices[0].delta.content
                    full_response += content
                    yield content

            self.chat_history.append({"role": "user", "content": prompt})
            self.chat_history.append({"role": "assistant", "content": full_response})

        except Exception as e:
            error_msg = f"⚠️ Error dalam X.AI API: {str(e)}"
            print(error_msg)
            yield error_msg

    async def stream_gemini_response(self, prompt: str, api_key: str) -> AsyncGenerator[str, None]:
        """Stream response dari Gemini API"""
        try:
            if not api_key:
                yield "⚠️ API Key Gemini diperlukan. Klik icon bantuan (?) di samping input API Key untuk panduan mendapatkan key."
                return

            genai.configure(api_key=api_key)
            model = genai.GenerativeModel('gemini-pro')
            
            # Tambahkan konteks repository jika ada
            if self.current_repo:
                context = f"Repository: {self.current_repo}\n\n"
                repo_files = "\n".join(list(self.repo_content.keys()))
                context += f"Files in repository:\n{repo_files}\n\n"
                prompt = context + prompt
            
            response = model.generate_content(
                prompt,
                generation_config={
                    "temperature": 0.7,
                    "top_p": 0.8,
                    "top_k": 40
                },
                stream=True
            )
            
            full_response = ""
            async for chunk in response:
                if chunk.text:
                    full_response += chunk.text
                    yield chunk.text
            
            self.chat_history.append({"role": "user", "content": prompt})
            self.chat_history.append({"role": "assistant", "content": full_response})
            
        except Exception as e:
            error_msg = f"⚠️ Error dalam Gemini API: {str(e)}\n\nPastikan API Key valid dan memiliki kuota yang cukup."
            print(error_msg)
            yield error_msg

    def clone_repository(self, repo_url: str, github_token: str, branch: str = None) -> tuple[bool, str]:
        """Clone repository GitHub dengan autentikasi"""
        if not repo_url:
            return False, "⚠️ URL repository diperlukan"

        repo_name = repo_url.split('/')[-1].replace('.git', '')
        
        if os.path.exists(repo_name):
            subprocess.run(['rm', '-rf', repo_name], check=True)

        try:
            owner_repo = '/'.join(repo_url.split('/')[-2:])
            
            # Cek apakah repository private
            headers = {'Authorization': f'token {github_token}'} if github_token else {}
            repo_check = requests.get(f"https://api.github.com/repos/{owner_repo}", headers=headers)
            
            if repo_check.status_code == 404:
                return False, "⚠️ Repository tidak ditemukan. Periksa URL repository."
            elif repo_check.status_code == 401:
                return False, "⚠️ Token GitHub tidak valid. Klik icon bantuan (?) untuk panduan mendapatkan token."
            elif repo_check.status_code == 403 and repo_check.json().get('private', False):
                return False, "⚠️ Ini adalah repository private. Token GitHub dengan akses 'repo' diperlukan."

            auth_url = f"https://{github_token}@github.com/{owner_repo}" if github_token else f"https://github.com/{owner_repo}"

            cmd = ['git', 'clone']
            if branch:
                cmd.extend(['--branch', branch])
            cmd.append(auth_url)

            process = subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                env=dict(os.environ, GIT_ASKPASS='echo', GIT_TERMINAL_PROMPT='0')
            )

            if process.returncode == 0:
                self.current_repo = repo_name
                # Scan dan simpan konten repository
                file_count = 0
                for file_path in Path(repo_name).rglob('*'):
                    if file_path.is_file() and '.git' not in str(file_path):
                        success, content = self.read_file_safely(str(file_path))
                        if success:
                            self.repo_content[str(file_path)] = content
                            file_count += 1
                
                return True, f"✅ Repository berhasil di-clone!\n\nNama: {repo_name}\nJumlah file: {file_count}\n\nAnda sekarang bisa mengajukan pertanyaan tentang repository ini."
            else:
                return False, f"⚠️ Gagal clone repository:\n{process.stderr}"
                
        except Exception as e:
            return False, f"⚠️ Error: {str(e)}"

    def read_file_safely(self, file_path: str) -> tuple[bool, str]:
        """Baca file dengan aman menggunakan berbagai encoding"""
        encodings = ['utf-8', 'latin-1', 'cp1252']
        for encoding in encodings:
            try:
                with open(file_path, 'r', encoding=encoding) as f:
                    content = f.read()
                    return True, content
            except Exception as e:
                continue
        return False, "Tidak dapat membaca file dengan encoding yang didukung"

def create_ui():
    analyzer = RepoAnalyzer()
    
    with gr.Blocks(title="Repository Chat Analysis") as app:
        gr.Markdown(f"""
        # 🤖 Repository Chat Analysis
        
        📅 Waktu: {CURRENT_TIME}
        👤 Pengguna: {CURRENT_USER}
        """)

        with gr.Tab("🛠️ Konfigurasi"):
            provider = gr.Radio(
                choices=[AIProvider.XAI, AIProvider.GEMINI, AIProvider.OLLAMA],
                label="Penyedia AI",
                value=AIProvider.XAI
            )
            
            with gr.Group() as api_settings:
                with gr.Row():
                    xai_key = gr.Textbox(
                        label="X.AI (Grok) API Key",
                        type="password",
                        placeholder="Opsional - Klik icon (?) untuk info. Kosongkan untuk gunakan key default",
                        show_label=True
                    )
                    gr.Markdown(XAI_API_HELP)
                
                with gr.Row():
                    gemini_key = gr.Textbox(
                        label="Gemini API Key",
                        type="password",
                        placeholder="Opsional - Kosongkan untuk gunakan key default",
                        show_label=True
                    )
                    gr.Markdown(GEMINI_API_HELP)

            # Model selection based on provider
            with gr.Row():
                model_dropdown = gr.Dropdown(
                    label="Model AI",
                    choices=XAI_MODELS,
                    value="grok-2-latest",
                    interactive=True
                )

            def update_model_list(provider_choice):
                if provider_choice == AIProvider.XAI:
                    return gr.Dropdown(choices=XAI_MODELS, value="grok-2-latest")
                elif provider_choice == AIProvider.GEMINI:
                    return gr.Dropdown(choices=GEMINI_MODELS, value="gemini-pro")
                else:  # OLLAMA
                    return gr.Dropdown(choices=OLLAMA_MODELS, value="llama2")
            
            provider.change(
                fn=update_model_list,
                inputs=[provider],
                outputs=[model_dropdown]
            )

        with gr.Tab("📊 Analisis Repository"):
            with gr.Row():
                repo_url = gr.Textbox(
                    label="URL Repository GitHub",
                    placeholder="Contoh: https://github.com/username/repository"
                )
                with gr.Column():
                    github_token = gr.Textbox(
                        label="Token GitHub", 
                        type="password",
                        placeholder="Klik icon (?) untuk panduan mendapatkan token"
                    )
                    gr.Markdown(GITHUB_TOKEN_HELP)
                branch = gr.Textbox(
                    label="Branch (opsional)",
                    placeholder="main"
                )
            
            clone_button = gr.Button("🔄 Clone Repository", variant="primary")
            clone_status = gr.Markdown(
                label="Status Repository",
            )
            
            gr.Markdown("""
            ### 💡 Contoh Pertanyaan:
            - "Jelaskan struktur utama dari repository ini"
            - "Apa saja fitur-fitur utama dalam kode ini?"
            - "Bagaimana cara memperbaiki [masalah specific] di repository ini?"
            - "Tolong analisis kualitas kode di file [nama file]"
            """)
            
            with gr.Row():
                chat_input = gr.Textbox(
                    label="💭 Tanyakan tentang Repository",
                    placeholder="Ketik pertanyaan Anda di sini...",
                    lines=3
                )
                send_button = gr.Button("📤 Kirim", variant="primary")
            
            chat_history = gr.Chatbot(
                label="📝 Riwayat Chat",
                height=500,
                show_label=True
            )

            async def handle_chat(message, history, provider_choice, model_name, xai_key, gemini_key):
                if not analyzer.current_repo:
                    yield history + [[message, "⚠️ Mohon clone repository terlebih dahulu sebelum mengajukan pertanyaan."]]
                    return
                
                history = history or []
                history.append([message, ""])
                
                full_response = ""
                if provider_choice == AIProvider.XAI:
                    async for chunk in analyzer.stream_xai_response(message, xai_key, model_name):
                        full_response += chunk
                        history[-1][1] = full_response
                        yield history
                elif provider_choice == AIProvider.GEMINI:
                    async for chunk in analyzer.stream_gemini_response(message, gemini_key or DEFAULT_GEMINI_KEY):
                        full_response += chunk
                        history[-1][1] = full_response
                        yield history
                else:  # OLLAMA
                    response = analyze_with_ollama(model_name, message)
                    history[-1][1] = response
                    yield history

            send_button.click(
                fn=handle_chat,
                inputs=[
                    chat_input,
                    chat_history,
                    provider,
                    model_dropdown,
                    xai_key,
                    gemini_key
                ],
                outputs=chat_history
            ).then(
                fn=lambda: gr.update(value=""),
                outputs=chat_input
            )

            chat_input.submit(
                fn=handle_chat,
                inputs=[
                    chat_input,
                    chat_history,
                    provider,
                    model_dropdown,
                    xai_key,
                    gemini_key
                ],
                outputs=chat_history
            ).then(
                fn=lambda: gr.update(value=""),
                outputs=chat_input
            )

    return app

if __name__ == "__main__":
    print(f"""
    🚀 Memulai Repository Chat Analysis
    📅 Waktu: {CURRENT_TIME}
    👤 Pengguna: {CURRENT_USER}
    """)
    
    app = create_ui()
    app.launch(share=True)