chore: add gemini

app.py

@@ -6,15 +6,64 @@ import requests
 import json
 from datetime import datetime
 import textwrap
+import google.generativeai as genai
+import asyncio
+from typing import Generator, AsyncGenerator
 
 # Metadata
-CURRENT_TIME = "2025-05-22 22:42:10"
+CURRENT_TIME = "2025-05-23 12:44:47"
 CURRENT_USER = "ErRickow"
 
-# Ollama API settings
-OLLAMA_API = os.environ["OLLAMA_API"]
-
-# Default available models
+# Link bantuan
+GITHUB_TOKEN_HELP = """
+### Cara Mendapatkan GitHub Token:
+
+1. Kunjungi [GitHub Token Settings](https://github.com/settings/tokens)
+2. Klik "Generate new token" > "Generate new token (classic)"
+3. Beri nama token Anda di "Note"
+4. Pilih scope:
+   - `repo` (untuk akses repository private)
+   - `read:packages` (opsional, untuk akses package)
+5. Klik "Generate token"
+6. **PENTING**: Salin token segera! Token hanya ditampilkan sekali
+
+Token diperlukan untuk:
+- Mengakses repository private
+- Clone repository dengan rate limit lebih tinggi
+- Mengakses fitur GitHub API
+"""
+
+GEMINI_API_HELP = """
+### Cara Mendapatkan Gemini API Key:
+
+1. Kunjungi [Google AI Studio](https://makersuite.google.com/app/apikey)
+2. Login dengan akun Google Anda
+3. Klik "Create API Key"
+4. Salin API Key yang dihasilkan
+
+Catatan:
+- Gemini memberikan kuota gratis setiap bulan
+- Key bisa dibuat ulang jika diperlukan
+- Monitor penggunaan di [Google Cloud Console](https://console.cloud.google.com/)
+"""
+
+OLLAMA_HELP = """
+### Cara Menggunakan Ollama:
+
+1. Install Ollama dari [ollama.ai](https://ollama.ai)
+2. Jalankan Ollama di komputer Anda
+3. Pastikan Ollama berjalan di http://localhost:11434
+
+Catatan:
+- Ollama berjalan secara lokal di komputer Anda
+- Tidak memerlukan API key
+- Ideal untuk privasi dan penggunaan offline
+"""
+
+# API settings
+OLLAMA_API = os.environ.get("OLLAMA_API", "http://localhost:11434")
+
+# Model lists
 DEFAULT_MODELS = [
     "llama2",
     "codellama",
@@ -26,287 +75,246 @@ DEFAULT_MODELS = [
     "orca-mini"
 ]
 
-def check_ollama_status():
-    try:
-        response = requests.get(f"{OLLAMA_API}/api/tags", timeout=10)
-        return response.status_code == 200
-    except:
-        return False
-
-def list_available_models():
-    try:
-        response = requests.get(f"{OLLAMA_API}/api/tags")
-        installed_models = [model['name'] for model in response.json().get('models', [])]
-        # Combine installed and default models
-        all_models = list(set(installed_models + DEFAULT_MODELS))
-        return sorted(all_models)  # Sort for better presentation
-    except:
-        return sorted(DEFAULT_MODELS)
-
-def download_model(model_name):
-    if not model_name:
-        return "Please select a model to download"
-    
-    print(f"Starting download of model: {model_name}")
-    try:
-        headers = {
-            "Content-Type": "application/json",
-        }
-        
-        response = requests.post(
-            f"{OLLAMA_API}/api/pull",
-            headers=headers,
-            json={"name": model_name},
-            stream=True
-        )
-        
-        if response.status_code == 200:
-            for line in response.iter_lines():
-                if line:
-                    print(f"Download progress: {line.decode()}")
-            return f"Successfully downloaded model: {model_name}"
-        else:
-            error_msg = f"Failed to download model. Status: {response.status_code}"
-            print(error_msg)
-            return error_msg
+class AIProvider:
+    OLLAMA = "ollama"
+    GEMINI = "gemini"
+
+class RepoAnalyzer:
+    def __init__(self):
+        self.current_repo = None
+        self.repo_content = {}
+        self.chat_history = []
+
+    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-1.5-mini')
             
-    except Exception as e:
-        error_msg = f"Error downloading model: {str(e)}"
-        print(error_msg)
-        return error_msg
-
-def clone_repository(repo_url, github_token, branch=None):
-    """Clone a repository with authentication"""
-    repo_name = repo_url.split('/')[-1].replace('.git', '')
-    print(f"Cloning repository: {repo_url} to {repo_name}")
-
-    if os.path.exists(repo_name):
-        print(f"Removing existing repository: {repo_name}")
-        subprocess.run(['rm', '-rf', repo_name], check=True)
-
-    try:
-        owner_repo = '/'.join(repo_url.split('/')[-2:])
-        auth_url = f"https://{github_token}@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:
-            print(f"Successfully cloned repository: {repo_name}")
-            return True, repo_name
-        else:
-            print(f"Failed to clone repository: {process.stderr}")
-            return False, process.stderr
-    except Exception as e:
-        error_msg = f"Error cloning repository: {str(e)}"
-        print(error_msg)
-        return False, error_msg
-
-def analyze_with_ollama(model_name, text):
-    """Process text with Ollama model"""
-    print(f"\nAnalyzing with {model_name}...")
-    try:
-        payload = {
-            "model": model_name,
-            "prompt": text,
-            "stream": False,
-            "options": {
-                "temperature": 0.7,
-                "top_p": 0.9,
-                "max_tokens": 2048,
-                "stop": None
-            }
-        }
-        
-        print("Sending request to Ollama API...")
-        response = requests.post(
-            f"{OLLAMA_API}/api/generate",
-            headers={"Content-Type": "application/json"},
-            json=payload,
-            timeout=60
-        )
-        
-        print(f"Response status: {response.status_code}")
-        
-        if response.status_code == 200:
-            result = response.json()
-            if 'response' in result:
-                print("Got response from model")
-                return result['response']
-            else:
-                print("Unexpected response format:", result)
-                return "Error: Unexpected response format from model"
-        else:
-            error_msg = f"API Error {response.status_code}: {response.text}"
-            print(error_msg)
-            return error_msg
+            # 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 processing with model: {str(e)}"
-        print(error_msg)
-        return error_msg
+        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"
 
-def chunk_text(text, max_length=4000):
-    return textwrap.wrap(text, max_length, break_long_words=False, break_on_hyphens=False)
+        repo_name = repo_url.split('/')[-1].replace('.git', '')
+        
+        if os.path.exists(repo_name):
+            subprocess.run(['rm', '-rf', repo_name], check=True)
 
-def read_file_safely(file_path):
-    encodings = ['utf-8', 'latin-1', 'cp1252']
-    for encoding in encodings:
         try:
-            with open(file_path, 'r', encoding=encoding) as f:
-                content = f.read()
-                print(f"Successfully read file with {encoding} encoding")
-                return True, content
-        except UnicodeDecodeError:
-            continue
+            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:
-            error_msg = f"Error reading file: {str(e)}"
-            print(error_msg)
-            return False, error_msg
-    return False, "Unable to read file with supported encodings"
+            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():
-    with gr.Blocks(title="Ollama Repository Analyzer") as app:
+    analyzer = RepoAnalyzer()
+    
+    with gr.Blocks(title="Repository Chat Analysis") as app:
         gr.Markdown(f"""
-        # Ollama Repository Analyzer
+        # 🤖 Repository Chat Analysis
         
-        Current Time: {CURRENT_TIME}
-        User: {CURRENT_USER}
+        📅 Waktu: {CURRENT_TIME}
+        👤 Pengguna: {CURRENT_USER}
         """)
 
-        with gr.Tab("Model Management"):
-            model_status = gr.Textbox(label="Ollama Status", interactive=False)
-            available_models = gr.Dropdown(
-                label="Available Models",
-                choices=DEFAULT_MODELS,
-                interactive=True
+        with gr.Tab("🛠️ Konfigurasi"):
+            provider = gr.Radio(
+                choices=[AIProvider.GEMINI, AIProvider.OLLAMA],
+                label="Penyedia AI",
+                value=AIProvider.GEMINI
             )
-            download_button = gr.Button("Download Selected Model")
-            download_status = gr.Textbox(label="Download Status", interactive=False)
-
-            def update_status():
-                status = "Connected" if check_ollama_status() else "Not Connected"
-                models = list_available_models()
-                return status, gr.Dropdown(choices=models)
-
-            download_button.click(
-                fn=download_model,
-                inputs=[available_models],
-                outputs=[download_status]
+            
+            with gr.Group() as api_settings:
+                with gr.Row():
+                    gemini_key = gr.Textbox(
+                        label="Gemini API Key",
+                        type="password",
+                        placeholder="Klik icon (?) untuk panduan mendapatkan API key",
+                        show_label=True
+                    )
+                    gr.Markdown(GEMINI_API_HELP)
+
+        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",
             )
-
-        with gr.Tab("Repository Analysis"):
-            repo_url = gr.Textbox(label="Repository URL")
-            github_token = gr.Textbox(label="GitHub Token", type="password")
-            branch = gr.Textbox(label="Branch (optional)")
-            clone_button = gr.Button("Clone Repository")
-            clone_status = gr.Textbox(label="Clone Status", interactive=False)
-
+            
+            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():
-                file_list = gr.Dropdown(label="Files in Repository", multiselect=True)
-                selected_model = gr.Dropdown(
-                    label="Select Model for Analysis",
-                    choices=DEFAULT_MODELS,
-                    interactive=True
+                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
+            )
 
-            analyze_button = gr.Button("Analyze Selected Files")
-            debug_output = gr.Textbox(label="Debug Output", interactive=False)
-            analysis_output = gr.Markdown()
-
-            def handle_clone(url, token, branch_name):
-                print(f"\nCloning repository: {url}")
-                success, result = clone_repository(url, token, branch_name if branch_name else None)
-                if success:
-                    files = [str(p) for p in Path(result).rglob('*')
-                            if p.is_file() and '.git' not in str(p)]
-                    print(f"Found {len(files)} files in repository")
-                    return f"Successfully cloned: {result}", gr.Dropdown(choices=files)
-                return f"Clone failed: {result}", None
-
-            def analyze_files(files, model_name):
-                if not files:
-                    return "Please select files to analyze", "No files selected"
-
-                debug_info = []
-                results = []
+            async def handle_chat(message, history, api_key):
+                if not analyzer.current_repo:
+                    return history + [[message, "⚠️ Mohon clone repository terlebih dahulu sebelum mengajukan pertanyaan."]]
                 
-                debug_info.append(f"Starting analysis with model: {model_name}")
-                debug_info.append(f"Files to analyze: {len(files)}")
+                history = history or []
+                history.append([message, ""])
                 
-                for file_path in files:
-                    debug_info.append(f"\nProcessing file: {file_path}")
-                    success, content = read_file_safely(file_path)
-                    
-                    if success:
-                        chunks = chunk_text(content)
-                        debug_info.append(f"Split into {len(chunks)} chunks")
-                        analysis = []
-                        
-                        for i, chunk in enumerate(chunks, 1):
-                            debug_info.append(f"Analyzing chunk {i}/{len(chunks)}")
-                            prompt = f"""
-                            Analyze this code/content:
-                            
-                            File: {file_path}
-                            Part {i}/{len(chunks)}
-                            
-                            ```
-                            {chunk}
-                            ```
-                            
-                            Provide:
-                            1. Brief overview
-                            2. Key functionality
-                            3. Notable patterns or concerns
-                            4. Suggestions (if any)
-                            """
-                            
-                            response = analyze_with_ollama(model_name, prompt)
-                            debug_info.append(f"Got response of length: {len(response)}")
-                            analysis.append(response)
-
-                        results.append(f"### Analysis of {file_path}\n\n" +
-                                     "\n\n=== Next Part ===\n\n".join(analysis))
-                    else:
-                        error_msg = f"Error reading {file_path}: {content}"
-                        debug_info.append(error_msg)
-                        results.append(error_msg)
-
-                return "\n\n---\n\n".join(results), "\n".join(debug_info)
+                full_response = ""
+                async for chunk in analyzer.stream_gemini_response(message, api_key):
+                    full_response += chunk
+                    history[-1][1] = full_response
+                    yield history
+
+            def handle_clone(url, token, branch_name):
+                success, result = analyzer.clone_repository(url, token, branch_name if branch_name else None)
+                return result
 
             clone_button.click(
                 fn=handle_clone,
                 inputs=[repo_url, github_token, branch],
-                outputs=[clone_status, file_list]
+                outputs=clone_status
             )
 
-            analyze_button.click(
-                fn=analyze_files,
-                inputs=[file_list, selected_model],
-                outputs=[analysis_output, debug_output]
+            send_button.click(
+                fn=handle_chat,
+                inputs=[chat_input, chat_history, gemini_key],
+                outputs=chat_history
+            ).then(
+                fn=lambda: gr.update(value=""),
+                outputs=chat_input
             )
 
-        # Update status every 30 seconds
-        app.load(update_status, outputs=[model_status, available_models])
+            chat_input.submit(
+                fn=handle_chat,
+                inputs=[chat_input, chat_history, gemini_key],
+                outputs=chat_history
+            ).then(
+                fn=lambda: gr.update(value=""),
+                outputs=chat_input
+            )
 
     return app
 
-# Launch the app
 if __name__ == "__main__":
     print(f"""
-    Starting Ollama Repository Analyzer
-    Time: {CURRENT_TIME}
-    User: {CURRENT_USER}
+    🚀 Memulai Repository Chat Analysis
+    📅 Waktu: {CURRENT_TIME}
+    👤 Pengguna: {CURRENT_USER}
     """)
     
     app = create_ui()