Update app.py

app.py

@@ -1,254 +1,336 @@
 import gradio as gr
 import os
-import requests
+import aiohttp
+import asyncio
 from git import Repo, GitCommandError
 from pathlib import Path
 from datetime import datetime
 import shutil
-import time
 import json
-import aiohttp
-import asyncio
-from typing import Dict, Optional, Tuple
 import logging
+import re
+from typing import Dict, List, Optional, Tuple
+import subprocess
+import plotly.graph_objects as go
+from transformers import pipeline  # For local fallback
+import threading
 
 # ========== Configuration ==========
-REPO_OWNER = "enricoros"
-REPO_NAME = "big-agi"
-MIAGI_FORK = "https://github.com/Ig0tU/miagi.git"
 WORKSPACE = Path("/tmp/issue_workspace")
 WORKSPACE.mkdir(exist_ok=True)
-HF_SPACE_API = "https://huggingface.co/api/spaces"  # Hypothetical HF Space API
-
-# Setup logging
+GITHUB_API = "https://api.github.com/repos"
+HF_INFERENCE_API = "https://api-inference.huggingface.co/models"
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# ========== Enhanced Theme ==========
+# Free Hugging Face models for selection
+HF_MODELS = {
+    "Mistral-8x7B (Powerful)": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+    "DistilBERT (Lightweight)": "distilbert-base-uncased",
+    "BART (Summarization)": "facebook/bart-large"
+}
+DEFAULT_MODEL = "mistralai/Mixtral-8x7B-Instruct-v0.1"
+
+# ========== Theme ==========
 theme = gr.themes.Default(
-    primary_hue="emerald",
-    secondary_hue="zinc",
+    primary_hue="indigo",
+    secondary_hue="slate",
     radius_size="lg",
 ).set(
-    button_primary_background_fill="*primary_500",
-    button_primary_background_fill_hover="*primary_400",
+    button_primary_background_fill="*primary_600",
     button_primary_text_color="white",
     block_label_background_fill="*primary_500",
     block_label_text_color="white",
-    body_background_fill="gray_100",
+    body_background_fill="gray_50",
 )
 
-# ========== State Management with Spaces Integration ==========
-class EnhancedIssueManager:
+# ========== Issue Manager ==========
+class IssueManager:
     def __init__(self):
         self.issues: Dict[int, dict] = {}
-        self.last_fetched: Optional[datetime] = None
-        self.current_issue: Optional[int] = None
+        self.repo_url: Optional[str] = None
         self.repo: Optional[Repo] = None
-        self.space_status: Dict = {}
-        self.progress_tracker = {}
+        self.current_issue: Optional[int] = None
+        self.github_token: Optional[str] = None
+        self.hf_token: Optional[str] = None
+        self.collaborators: Dict[str, str] = {}
+        self.local_nlp = None  # Local fallback
+        self.webhook_active = False
         
-    async def fetch_issues(self) -> Tuple[bool, str]:
-        if self.last_fetched and (datetime.now() - self.last_fetched).seconds < 300:
-            return True, "Using cached issues"
+    async def crawl_issues(self, repo_url: str, github_token: str, hf_token: str) -> Tuple[bool, str]:
+        self.repo_url = repo_url
+        self.github_token = github_token
+        self.hf_token = hf_token
+        match = re.match(r"https://github.com/([^/]+)/([^/]+)", repo_url)
+        if not match:
+            return False, "Invalid GitHub URL format"
             
+        owner, repo_name = match.groups()
+        all_issues = []
+        page = 1
+        headers = {"Authorization": f"Bearer {github_token}", "Accept": "application/vnd.github+json"}
+        
         try:
-            headers = {"Authorization": f"Bearer {os.environ.get('GITHUB_TOKEN', '')}"}
             async with aiohttp.ClientSession() as session:
-                async with session.get(f"https://api.github.com/repos/{REPO_OWNER}/{REPO_NAME}/issues", 
-                                    headers=headers) as response:
-                    response.raise_for_status()
-                    self.issues = {issue['number']: issue for issue in await response.json()}
-                    self.last_fetched = datetime.now()
-                    return True, "Successfully fetched issues"
-        except Exception as e:
-            logger.error(f"Error fetching issues: {e}")
-            return False, f"Failed to fetch issues: {str(e)}"
+                while True:
+                    url = f"{GITHUB_API}/{owner}/{repo_name}/issues?page={page}&state=open"
+                    async with session.get(url, headers=headers) as response:
+                        if response.status == 403:
+                            return False, "GitHub rate limit exceeded or invalid token"
+                        if response.status != 200:
+                            return False, f"GitHub API error: {response.status}"
+                        issues = await response.json()
+                        if not issues:
+                            break
+                        all_issues.extend(issues)
+                        page += 1
 
-    async def check_space_status(self, issue_number: int) -> Dict:
-        """Check if issue relates to a Hugging Face Space"""
-        try:
-            headers = {"Authorization": f"Bearer {os.environ.get('HF_TOKEN', '')}"}
-            async with aiohttp.ClientSession() as session:
-                async with session.get(f"{HF_SPACE_API}/{REPO_OWNER}/{REPO_NAME}",
-                                    headers=headers) as response:
-                    if response.status == 200:
-                        space_data = await response.json()
-                        self.space_status[issue_number] = space_data
-                        return {"space_found": True, "data": space_data}
-            return {"space_found": False}
+            self.issues = {
+                i['number']: {**i, 'severity': self._determine_severity(i)}
+                for i in all_issues if not i.get('assignee')
+            }
+            return True, f"Found {len(self.issues)} unresolved/unassigned issues"
         except Exception as e:
-            logger.error(f"Space check failed: {e}")
-            return {"space_found": False, "error": str(e)}
-
-issue_manager = EnhancedIssueManager()
-
-# ========== Core Functions with Space Handling ==========
-async def replicate_issue(issue_number: str) -> Tuple[Dict, str, gr.update]:
-    try:
-        issue_number = int(issue_number)
-        success, fetch_message = await issue_manager.fetch_issues()
-        if not success:
-            return {"error": f"⚠️ {fetch_message}"}, None, None
-            
-        if issue_number not in issue_manager.issues:
-            return {"error": f"❌ Issue #{issue_number} not found"}, None, None
-            
-        issue = issue_manager.issues[issue_number]
-        repo_path = WORKSPACE / f"miagi-{issue_number}"
-        issue_manager.progress_tracker[issue_number] = {"status": "initializing"}
-        
-        # Check Space status
-        space_status = await issue_manager.check_space_status(issue_number)
-        
-        # Clone with progress
+            logger.error(f"Crawl error: {e}")
+            return False, str(e)
+
+    def _determine_severity(self, issue: dict) -> str:
+        body = (issue.get('body') or '').lower()
+        labels = [l['name'].lower() for l in issue.get('labels', [])]
+        if any(l in labels for l in ['critical', 'urgent', 'security']) or 'crash' in body:
+            return "Critical"
+        elif any(l in labels for l in ['high', 'important']) or 'error' in body:
+            return "High"
+        elif any(l in labels for l in ['medium', 'bug']) or 'issue' in body:
+            return "Medium"
+        return "Low"
+
+    async def clone_and_work(self, issue_number: int) -> Tuple[Dict, str, str]:
         try:
-            issue_manager.progress_tracker[issue_number] = {"status": "cloning"}
-            repo = Repo.clone_from(MIAGI_FORK, repo_path, branch="main",
-                                 progress=lambda x: issue_manager.progress_tracker[issue_number].update({"progress": x}))
-        except GitCommandError:
-            repo = Repo(repo_path)
+            repo_path = WORKSPACE / f"repo-{issue_number}"
+            if repo_path.exists():
+                shutil.rmtree(repo_path)
+                
+            self.repo = Repo.clone_from(self.repo_url, repo_path)
+            branch = f"issue-{issue_number}"
+            self.repo.git.checkout('-b', branch)
+            self.current_issue = issue_number
             
-        branch_name = f"issue-{issue_number}"
-        repo.git.checkout('-b', branch_name)
-        
-        # Handle Space replication if applicable
-        issues_dir = repo_path / "issues" / str(issue_number)
-        issues_dir.mkdir(parents=True, exist_ok=True)
-        
-        replication_details = {
-            "timestamp": datetime.utcnow().isoformat(),
-            "space_status": space_status
-        }
-        (issues_dir / "replication.json").write_text(json.dumps(replication_details))
-        
-        issue_manager.repo = repo
-        issue_manager.current_issue = issue_number
-        
-        return {
-            "success": f"🚀 Replicated issue #{issue_number}",
-            "space": space_status,
-            "progress": issue_manager.progress_tracker[issue_number]
-        }, issue["body"], gr.update(selected=1)
-        
-    except Exception as e:
-        logger.error(f"Replication error: {e}")
-        return {"error": f"⛔ Critical error: {str(e)}"}, None, None
+            issue = self.issues[issue_number]
+            diff = ""
+            return {"success": f"Working on #{issue_number}"}, issue['body'], diff
+        except GitCommandError as e:
+            return {"error": str(e)}, "", ""
 
-async def resolve_issue(resolution_notes: str, space_config: Optional[str] = None) -> Tuple[Dict, gr.update]:
-    if not issue_manager.current_issue:
-        return {"error": "⚠️ No active issue selected"}, None
-        
-    try:
-        repo = issue_manager.repo
-        issue_number = issue_manager.current_issue
-        resolution_dir = repo.working_dir / "issues" / str(issue_number)
+    async def suggest_resolution(self, issue_number: int, model: str) -> str:
+        """Use HF Inference API or local fallback"""
+        issue = self.issues[issue_number]
+        prompt = f"Suggest a detailed resolution for this GitHub issue:\nTitle: {issue['title']}\nBody: {issue['body']}"
         
-        timestamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
-        resolution_data = {
-            "notes": resolution_notes,
-            "space_config": space_config,
-            "resolved_at": timestamp
-        }
-        
-        (resolution_dir / f"resolution_{timestamp}.json").write_text(json.dumps(resolution_data))
-        (resolution_dir / "RESOLVED").touch()
-        
-        return {"success": "🔧 Resolution saved"}, gr.update(visible=True)
-    except Exception as e:
-        return {"error": f"⛔ Resolution failed: {str(e)}"}, None
+        if self.hf_token:
+            headers = {"Authorization": f"Bearer {self.hf_token}"}
+            payload = {"inputs": prompt, "parameters": {"max_new_tokens": 200}}
+            try:
+                async with aiohttp.ClientSession() as session:
+                    async with session.post(f"{HF_INFERENCE_API}/{model}", headers=headers, json=payload) as resp:
+                        if resp.status == 200:
+                            result = await resp.json()
+                            return result[0].get("generated_text", "No suggestion").strip()
+                        elif resp.status == 429:
+                            return await self._local_suggestion(prompt)
+                        return f"HF API error: {resp.status}"
+            except Exception as e:
+                logger.error(f"HF suggestion error: {e}")
+                return await self._local_suggestion(prompt)
+        return await self._local_suggestion(prompt)
 
-async def submit_resolution() -> Dict:
-    if not issue_manager.current_issue:
-        return {"error": "⚠️ No active issue selected"}
-        
-    try:
-        repo = issue_manager.repo
-        issue_number = issue_manager.current_issue
-        
-        repo.git.add(all=True)
-        commit_message = f"Resolve #{issue_number}: {issue_manager.issues[issue_number]['title']}"
-        repo.index.commit(commit_message)
-        
-        origin = repo.remote(name='origin')
-        branch_name = f"issue-{issue_number}"
-        origin.push(refspec=f"{branch_name}:{branch_name}")
+    async def _local_suggestion(self, prompt: str) -> str:
+        """Fallback to local model"""
+        if not self.local_nlp:
+            self.local_nlp = pipeline("text-generation", model="distilgpt2", device=-1)  # CPU-only, lightweight
+        try:
+            result = self.local_nlp(prompt, max_length=200, num_return_sequences=1)
+            return result[0]["generated_text"].strip()
+        except Exception as e:
+            logger.error(f"Local fallback error: {e}")
+            return "Local suggestion unavailable"
+
+    async def resolve_and_verify(self, resolution: str) -> Tuple[Dict, str]:
+        if not self.current_issue or not self.repo:
+            return {"error": "No active issue/repo"}, ""
+            
+        issue_number = self.current_issue
+        repo_path = self.repo.working_dir
         
-        # Space-specific submission if applicable
-        if issue_manager.space_status.get(issue_number, {}).get("space_found"):
-            await self._update_space_config(issue_number)
+        try:
+            resolution_dir = repo_path / "resolutions" / str(issue_number)
+            resolution_dir.mkdir(parents=True, exist_ok=True)
+            timestamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
+            resolution_file = resolution_dir / f"resolution_{timestamp}.txt"
+            resolution_file.write_text(resolution)
             
-        pr_url = f"https://github.com/Ig0tU/miagi/compare/{branch_name}?expand=1"
-        return {
-            "success": f"🚀 Resolution submitted!\n\n[Review PR]({pr_url})",
-            "pr_url": pr_url
-        }
-    except Exception as e:
-        return {"error": f"⛔ Submission failed: {str(e)}"}
+            self.repo.git.add(all=True)
+            self.repo.index.commit(f"Resolve #{issue_number}")
+            diff = self.repo.git.diff('HEAD^', 'HEAD')
+            
+            v1 = await self._verify_resolution(issue_number, resolution)
+            await asyncio.sleep(1)
+            v2 = await self._verify_resolution(issue_number, resolution)
+            
+            if v1["status"] and v2["status"]:
+                self.repo.git.push('origin', f"issue-{issue_number}")
+                pr_url = await self._create_pr(issue_number)
+                return {
+                    "success": f"Issue #{issue_number} resolved and verified",
+                    "pr_url": pr_url,
+                    "verification": [v1, v2]
+                }, diff
+            return {"error": "Verification failed", "details": [v1, v2]}, diff
+            
+        except Exception as e:
+            logger.error(f"Resolve error: {e}")
+            return {"error": str(e)}, ""
 
-    async def _update_space_config(self, issue_number: int):
-        """Update Hugging Face Space configuration"""
+    async def _verify_resolution(self, issue_number: int, resolution: str) -> Dict:
+        issue = self.issues[issue_number]
+        body = issue['body'].lower()
         try:
-            headers = {"Authorization": f"Bearer {os.environ.get('HF_TOKEN', '')}"}
-            config = {"issue_number": issue_number, "status": "resolved"}
-            async with aiohttp.ClientSession() as session:
-                await session.post(
-                    f"{HF_SPACE_API}/{REPO_OWNER}/{REPO_NAME}/config",
-                    json=config,
-                    headers=headers
+            diff = self.repo.git.diff('HEAD^', 'HEAD')
+            if 'file' in body:
+                file_match = re.search(r'file:\s*(\S+)', body)
+                if file_match and file_match.group(1) not in diff:
+                    return {"status": False, "message": "Resolution doesn’t modify mentioned file"}
+            
+            if (self.repo.working_dir / "tests").exists():
+                proc = await asyncio.create_subprocess_exec(
+                    "pytest", cwd=self.repo.working_dir, stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
                 )
+                stdout, stderr = await proc.communicate()
+                if proc.returncode != 0:
+                    return {"status": False, "message": f"Tests failed: {stderr.decode()}"}
+            
+            return {"status": True, "message": "Resolution verified"}
         except Exception as e:
-            logger.error(f"Space config update failed: {e}")
+            return {"status": False, "message": str(e)}
 
-# ========== Enhanced UI ==========
-def create_enhanced_ui():
-    with gr.Blocks(theme=theme, css="footer {visibility: hidden}") as app:
-        gr.Markdown("# 🚀 Enhanced Repository Manager\n### With Hugging Face Spaces Integration")
-        
-        with gr.Tabs() as tabs:
-            with gr.Tab("🔍 Investigate"):
-                with gr.Row():
-                    issue_input = gr.Number(label="Issue Number")
-                    replicate_btn = gr.Button("⚡ Replicate", variant="primary")
-                status_output = gr.JSON(label="Replication Status")
-                progress_bar = gr.Progress()
+    async def _create_pr(self, issue_number: int) -> str:
+        owner, repo_name = re.match(r"https://github.com/([^/]+)/([^/]+)", self.repo_url).groups()
+        headers = {"Authorization": f"Bearer {self.github_token}", "Accept": "application/vnd.github+json"}
+        pr_data = {
+            "title": f"Resolve #{issue_number}: {self.issues[issue_number]['title']}",
+            "body": f"Resolution for #{issue_number}\nVerification: Passed twice",
+            "head": f"issue-{issue_number}",
+            "base": "main"
+        }
+        async with aiohttp.ClientSession() as session:
+            resp = await session.post(f"{GITHUB_API}/{owner}/{repo_name}/pulls", headers=headers, json=pr_data)
+            if resp.status == 201:
+                return (await resp.json())['html_url']
+            raise Exception(f"PR creation failed: {await resp.text()}")
 
-            with gr.Tab("🔧 Resolve"):
-                with gr.Row():
-                    with gr.Column():
-                        issue_desc = gr.Markdown()
-                        resolution_input = gr.Textbox(lines=8, label="Resolution Notes")
-                        space_config = gr.Textbox(lines=2, label="Space Config (if applicable)")
-                        resolve_btn = gr.Button("💾 Save", variant="primary")
-                    with gr.Column():
-                        file_explorer = gr.FileExplorer()
-
-            with gr.Tab("🚀 Deploy"):
-                deploy_btn = gr.Button("🔥 Submit", variant="primary")
-                pr_output = gr.Markdown()
-                space_status = gr.JSON(label="Space Status")
-
-        # Event handlers with async support
-        replicate_btn.click(
-            fn=replicate_issue,
-            inputs=issue_input,
-            outputs=[status_output, issue_desc, tabs]
+    def get_stats(self) -> go.Figure:
+        severity_counts = {s: sum(1 for i in self.issues.values() if i['severity'] == s) for s in ["Critical", "High", "Medium", "Low"]}
+        return go.Figure(
+            data=[go.Bar(x=list(severity_counts.keys()), y=list(severity_counts.values()))],
+            layout={"title": "Issue Severity Distribution"}
         )
+
+    async def webhook_listener(self):
+        """Simulated webhook for real-time updates"""
+        while self.webhook_active:
+            await asyncio.sleep(10)  # Poll every 10s (replace with real webhook in production)
+            await self.crawl_issues(self.repo_url, self.github_token, self.hf_token)
+            logger.info("Webhook: Issues refreshed")
+
+manager = IssueManager()
+
+# ========== UI ==========
+def create_ui():
+    with gr.Blocks(theme=theme, title="Hugging Face Git Resolver") as app:
+        gr.Markdown("# 🤗 Hugging Face Git Resolver\nFree AI-powered issue resolution for all")
+        current_diff = gr.State(value="")
         
-        resolve_btn.click(
-            fn=resolve_issue,
-            inputs=[resolution_input, space_config],
-            outputs=[status_output, deploy_btn]
-        )
+        with gr.Row():
+            repo_url = gr.Textbox(label="GitHub Repository URL", placeholder="https://github.com/username/repo")
+            github_token = gr.Textbox(label="GitHub Token", type="password")
+            hf_token = gr.Textbox(label="Hugging Face Token", type="password")
+            model_select = gr.Dropdown(choices=list(HF_MODELS.keys()), value="Mistral-8x7B (Powerful)", label="AI Model")
+            crawl_btn = gr.Button("Crawl Issues", variant="primary")
         
-        deploy_btn.click(
-            fn=submit_resolution,
-            outputs=[status_output, pr_output, space_status]
-        )
+        with gr.Tabs():
+            with gr.Tab("Issues"):
+                status = gr.Textbox(label="Status")
+                issue_list = gr.Dataframe(
+                    headers=["Number", "Title", "Severity"],
+                    datatype=["number", "str", "str"],
+                    interactive=True
+                )
+                progress = gr.Progress()
+            
+            with gr.Tab("Work"):
+                with gr.Row():
+                    issue_num = gr.Number(label="Issue Number")
+                    work_btn = gr.Button("Start Work")
+                issue_body = gr.Markdown()
+                with gr.Row():
+                    resolution = gr.Textbox(label="Resolution", lines=5)
+                    suggest_btn = gr.Button("AI Suggest")
+                diff_view = gr.HTML(label="Changes Preview")
+                resolve_btn = gr.Button("Resolve & Verify", variant="primary")
+                result = gr.JSON()
+            
+            with gr.Tab("Dashboard"):
+                stats_plot = gr.Plot(label="Issue Stats")
+                collab_status = gr.Textbox(label="Collaborators Online", value="No collaborators yet")
+        
+        # Event Handlers
+        async def crawl_and_display(url, g_token, h_token, model):
+            success, msg = await manager.crawl_issues(url, g_token, h_token)
+            if success:
+                sorted_issues = sorted(manager.issues.values(), key=lambda x: {"Critical": 0, "High": 1, "Medium": 2, "Low": 3}[x['severity']])
+                df = [[i['number'], i['title'], i['severity']] for i in sorted_issues]
+                if not manager.webhook_active:
+                    manager.webhook_active = True
+                    asyncio.create_task(manager.webhook_listener())
+                return msg, gr.Dataframe(value=df), manager.get_stats()
+            return msg, gr.Dataframe(), None
+
+        async def start_work(num):
+            result, body, diff = await manager.clone_and_work(int(num))
+            diff_html = f"<pre>{diff}</pre>" if diff else "No changes yet"
+            return result, body, diff_html, diff
+
+        async def suggest_res(num, model):
+            suggestion = await manager.suggest_resolution(int(num), HF_MODELS[model])
+            return suggestion
+
+        async def resolve_issue(res, diff_state):
+            result, diff = await manager.resolve_and_verify(res)
+            diff_html = f"<pre>{diff}</pre>" if diff else "No changes"
+            return result, diff_html, diff
+
+        def select_issue(evt: gr.SelectData):
+            num = evt.value[0]
+            return num, manager.issues[num]['body']
+
+        issue_list.select(select_issue, None, [issue_num, issue_body])
+        crawl_btn.click(crawl_and_display, [repo_url, github_token, hf_token, model_select], [status, issue_list, stats_plot])
+        work_btn.click(start_work, [issue_num], [status, issue_body, diff_view, current_diff])
+        suggest_btn.click(suggest_res, [issue_num, model_select], [resolution])
+        resolve_btn.click(resolve_issue, [resolution, current_diff], [result, diff_view, current_diff])
+
+        async def update_collab():
+            while True:
+                await asyncio.sleep(5)
+                manager.collaborators["user1"] = "Working on #5"  # Simulated
+                yield "\n".join(f"{k}: {v}" for k, v in manager.collaborators.items())
+
+        app.load(fn=update_collab, inputs=None, outputs=collab_status, _js="() => setInterval(() => gradioApp().dispatchEvent(new Event('update_collab')), 5000)")
 
     return app
 
 # ========== Execution ==========
 if __name__ == "__main__":
-    app = create_enhanced_ui()
-    app.launch(server_port=7860, share=True)
+    app = create_ui()
+    app.launch(share=True)