Update app.py

app.py

@@ -1,6 +1,6 @@
-import gradio as gr 
+import gradio as gr
 import langchain
-import huggingface_hub 
+import huggingface_hub
 import dotenv
 import PyYaml
 from typing import Optional, Union, List, Dict, Any, Tuple
@@ -10,8 +10,14 @@ import json
 import tempfile
 from datetime import datetime, timezone
 import re
+import requests
+import logging
+import shutil
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
 
-# Add these utility classes based on git-bob's architecture
 class TerminalCommand:
     @staticmethod
     def execute(command: Union[str, List[str]], cwd: Optional[str] = None) -> Tuple[str, str, int]:
@@ -20,7 +26,7 @@ class TerminalCommand:
         """
         if isinstance(command, str):
             command = command.split()
-        
+
         try:
             process = subprocess.Popen(
                 command,
@@ -32,6 +38,7 @@ class TerminalCommand:
             stdout, stderr = process.communicate()
             return stdout.strip(), stderr.strip(), process.returncode
         except Exception as e:
+            logger.error(f"Error executing command {command}: {e}")
             return "", str(e), 1
 
 class GitUtilities:
@@ -40,263 +47,169 @@ class GitUtilities:
 
     def clone(self, url: str, branch: str = "main") -> bool:
         """Clone a repository"""
-        _, stderr, code = TerminalCommand.execute(
+        stdout, stderr, code = TerminalCommand.execute(
             f"git clone -b {branch} {url} {self.repo_path}"
         )
+        if code != 0:
+            logger.error(f"Git clone failed: {stderr}")
         return code == 0
 
     def commit(self, message: str) -> bool:
         """Create a commit with the given message"""
-        _, _, code = TerminalCommand.execute(
+        stdout, stderr, code = TerminalCommand.execute(
             ["git", "commit", "-m", message],
             str(self.repo_path)
         )
+        if code != 0:
+            logger.error(f"Git commit failed: {stderr}")
         return code == 0
 
     def push(self, remote: str = "origin", branch: str = "main") -> bool:
         """Push changes to remote"""
-        _, _, code = TerminalCommand.execute(
+        stdout, stderr, code = TerminalCommand.execute(
             ["git", "push", remote, branch],
             str(self.repo_path)
         )
+        if code != 0:
+            logger.error(f"Git push failed: {stderr}")
         return code == 0
 
     def create_branch(self, branch_name: str) -> bool:
         """Create and checkout a new branch"""
-        _, _, code = TerminalCommand.execute(
+        stdout, stderr, code = TerminalCommand.execute(
             ["git", "checkout", "-b", branch_name],
             str(self.repo_path)
         )
+        if code != 0:
+            logger.error(f"Git branch creation failed: {stderr}")
         return code == 0
 
-# Enhance the GitHubBot class with new features
 class GitHubBot:
     def __init__(self, logger: logging.Logger):
         self.github_api = None
         self.logger = logger
         self.ai_provider = None
-        self.file_types = {
-            '.py': {'language': 'Python', 'parser': 'python'},
-            '.js': {'language': 'JavaScript', 'parser': 'javascript'},
-            '.ts': {'language': 'TypeScript', 'parser': 'typescript'},
-            '.java': {'language': 'Java', 'parser': 'java'},
-            '.cpp': {'language': 'C++', 'parser': 'cpp'},
-            '.go': {'language': 'Go', 'parser': 'go'},
-            '.rs': {'language': 'Rust', 'parser': 'rust'}
-        }
         self.git = None
         self.temp_dir = None
+        self.base_url = "https://api.github.com"
 
-    def initialize_api(self, token: str, ai_provider: AIProvider = None):
-        self.github_api = GitHubAPI(token, self.logger)
-        self.ai_provider = ai_provider
+    def initialize_api(self, token: str):
+        """Initialize the GitHub API with a token."""
+        if not token:
+            raise ValueError("GitHub token is required.")
+        self.github_api = {"Authorization": f"Bearer {token}"}
         self.temp_dir = tempfile.mkdtemp()
         self.git = GitUtilities(self.temp_dir)
 
     def create_pull_request(self, owner: str, repo: str, title: str, body: str, head: str, base: str = "main") -> Dict:
-        """Create a pull request"""
-        url = f"{self.github_api.base_url}/repos/{owner}/{repo}/pulls"
+        """Create a pull request."""
+        url = f"{self.base_url}/repos/{owner}/{repo}/pulls"
         data = {
             "title": title,
             "body": body,
             "head": head,
             "base": base
         }
-        response = requests.post(url, headers=self.github_api.headers, json=data)
-        response.raise_for_status()
-        return response.json()
-
-def resolve_issue(self, token: str, owner: str, repo: str, issue_number: int, resolution: str, forked_repo: str) -> str:
-    try:
-        if not self.ai_provider:
-            raise ValueError("AI provider not initialized. Please initialize with an AI provider.")
-
-        # Create a unique branch name for this fix
-        branch_name = f"fix/issue-{issue_number}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
-
-        # Clone repository and create new branch
-        if not self.git.clone(forked_repo):
-            raise Exception("Failed to clone repository")
-
-        if not self.git.create_branch(branch_name):
-            raise Exception("Failed to create branch")
-
-        # Get repository content and analyze
-        code_contexts = self._get_main_branch_content(owner, repo)
-        
-        # Get issue details
-        issue_url = f"{self.github_api.base_url}/repos/{owner}/{repo}/issues/{issue_number}"
-        response = requests.get(issue_url, headers=self.github_api.headers)
-        response.raise_for_status()
-        issue = response.json()
-
-        # Determine severity
-        severity = self._determine_severity(issue)
-        
-        # Generate AI solution
-        context = f"Repository: {owner}/{repo}\nIssue #{issue_number}: {issue['title']}\n\nCode contexts:\n"
-        for ctx in code_contexts[:3]:
-            context += f"\nFile: {ctx.file_path}\n```{ctx.language}\n{ctx.content}\n```\n"
-        
-        ai_solution = self.ai_provider.generate_solution(context, issue['body'])
-        
-        # Create comprehensive resolution document
-        full_resolution = self._create_resolution_document(
-            issue_number, severity, resolution, ai_solution
-        )
-        
-        # Save resolution
-        resolution_path = Path(RESOLUTIONS_DIRECTORY) / f"resolution_{issue_number}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
-        resolution_path.write_text(full_resolution)
-
-        # Prompt for manual intervention
-        print("\nAI-generated solution and original resolution have been saved.")
-        print(f"Please review and apply changes in: {self.temp_dir}")
-        input("Press Enter when changes are ready to commit...")
-
-        # Commit and push changes
-        if not self.git.commit(f"Fix #{issue_number}: {issue['title']}\n\n{resolution}"):
-            raise Exception("Failed to commit changes")
-
-        if not self.git.push("origin", branch_name):
-            raise Exception("Failed to push changes")
-
-        # Create pull request
-        pr = self.create_pull_request(
-            owner=owner,
-            repo=repo,
-            title=f"Fix #{issue_number}: {issue['title']}",
-            body=full_resolution,
-            head=branch_name
-        )
-
-        return f"Resolution implemented and PR created: {pr['html_url']}"
-
-    except Exception as e:
-        error_msg = f"Error resolving issue #{issue_number} in repository {owner}/{repo}: {str(e)}"
-        self.logger.error(error_msg)
-        return error_msg
-
-    finally:
-        # Cleanup
-        if self.temp_dir and os.path.exists(self.temp_dir):
-            shutil.rmtree(self.temp_dir)
+        try:
+            response = requests.post(url, headers=self.github_api, json=data)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            logger.error(f"Error creating pull request: {e}")
+            raise
+
+    def resolve_issue(self, token: str, owner: str, repo: str, issue_number: int, resolution: str, forked_repo: str) -> str:
+        """Resolve a GitHub issue."""
+        try:
+            self.initialize_api(token)
+            branch_name = f"fix/issue-{issue_number}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+
+            # Clone repository
+            if not self.git.clone(forked_repo):
+                raise Exception("Failed to clone repository")
+
+            # Create a new branch
+            if not self.git.create_branch(branch_name):
+                raise Exception("Failed to create branch")
+
+            # Generate resolution content
+            resolution_content = self._create_resolution_document(issue_number, resolution)
+
+            # Save resolution file
+            resolution_path = Path(self.temp_dir) / f"resolution_{issue_number}.md"
+            with open(resolution_path, "w") as f:
+                f.write(resolution_content)
+
+            # Commit and push changes
+            if not self.git.commit(f"Fix for issue #{issue_number}"):
+                raise Exception("Failed to commit changes")
+            if not self.git.push("origin", branch_name):
+                raise Exception("Failed to push changes")
+
+            # Create a pull request
+            pr = self.create_pull_request(
+                owner=owner,
+                repo=repo,
+                title=f"Fix for issue #{issue_number}",
+                body="This PR resolves the reported issue with the following resolution.",
+                head=branch_name
+            )
 
-def _create_resolution_document(self, issue_number: int, severity: IssueSeverity, 
-                                 resolution: str, ai_solution: str) -> str:
-    """Create a comprehensive resolution document"""
-    return f"""# Resolution for Issue #{issue_number}
-## Severity: {severity.name}
-## Original Resolution
+            return f"Pull request created: {pr['html_url']}"
+        except Exception as e:
+            logger.error(f"Error resolving issue #{issue_number}: {e}")
+            return f"Error: {e}"
+        finally:
+            if self.temp_dir and os.path.exists(self.temp_dir):
+                shutil.rmtree(self.temp_dir)
+
+    def _create_resolution_document(self, issue_number: int, resolution: str) -> str:
+        """Create a resolution document."""
+        return f"""# Resolution for Issue #{issue_number}
+## Resolution Details
 {resolution}
-## AI-Generated Solution
-{ai_solution}
-## Implementation Details
-- Implementation Date: {datetime.now(timezone.utc).isoformat()}
-- Severity Level: {severity.name}
-- Resolution Type: {'AI-ASSISTED' if ai_solution else 'MANUAL'}
-## Testing Notes
-- [ ] Code changes have been tested locally
-- [ ] All tests pass
-- [ ] No new issues introduced
-## Review Checklist
-- [ ] Code follows project style guidelines
-- [ ] Documentation has been updated
-- [ ] Changes are properly tested
-- [ ] No security vulnerabilities introduced
-## Additional Notes
-Please review the changes carefully before merging.
-"""
-
-    # The following lines should not be part of the _create_resolution_document method
-    script_file = f"{RESOLUTIONS_DIRECTORY}/resolve_issue_{issue_number}.sh"
-    with open(script_file, "w") as f:
-        f.write(bash_script)
-
-    # Make the script executable
-    os.chmod(script_file, 0o755)
+## Metadata
+- Date: {datetime.now(timezone.utc).isoformat()}
+- Resolved By: Automated System
+        """
 
-    return f"Bash script generated: {script_file}"
+def create_gradio_interface():
+    """Create the Gradio interface."""
+    bot = GitHubBot(logger)
 
-    except Exception as e:
-        error_msg = f"Error resolving issue #{issue_number} in repository {owner}/{repo}: {str(e)}"
-        self.logger.error(error_msg)
-        return error_msg
+    def on_resolve(token, repo_url, issue_number, resolution, forked_repo):
+        try:
+            parts = repo_url.strip("/").split("/")
+            owner, repo = parts[-2], parts[-1]
+            result = bot.resolve_issue(token, owner, repo, int(issue_number), resolution, forked_repo)
+            return result
+        except Exception as e:
+            logger.error(f"Error in issue resolution: {e}")
+            return f"Error: {e}"
 
-def create_gradio_interface():
     with gr.Blocks() as demo:
-        gr.Markdown("# Enhanced GitHub Issue Resolver")
-        gr.Markdown("AI-assisted issue resolution with integrated git operations")
-        
-        with gr.Tab("Configuration"):
-            with gr.Row():
-                token_input = gr.Textbox(label="GitHub Token", placeholder="Enter your GitHub token")
-                repo_url_input = gr.Textbox(label="Repository URL", placeholder="Enter the repository URL (owner/repo)")
-
-            with gr.Row():
-                ai_api_base = gr.Textbox(label="AI API Base URL", placeholder="Enter your AI API base URL")
-                ai_api_key = gr.Textbox(label="AI API Key", placeholder="Enter your AI API key")
+        gr.Markdown("# GitHub Issue Resolver")
+        gr.Markdown("Resolve GitHub issues with AI assistance and Git integration.")
 
         with gr.Tab("Issue Resolution"):
             with gr.Row():
-                issue_number_input = gr.Number(label="Issue Number", info="Enter the issue number")
-                severity_indicator = gr.Label(label="Issue Severity")
-
-            resolution_input = gr.Textbox(label="Resolution", placeholder="Describe the resolution for the issue", lines=4)
-            forked_repo_input = gr.Textbox(label="Forked Repository URL", placeholder="Enter the forked repository URL")
-
-            with gr.Row():
-                analyze_button = gr.Button("Analyze Issue")
-                resolve_button = gr.Button("Resolve Issue")
+                token_input = gr.Textbox(label="GitHub Token", placeholder="Enter your GitHub token")
+                repo_url_input = gr.Textbox(label="Repository URL", placeholder="Enter the repository URL")
+                issue_number_input = gr.Number(label="Issue Number", precision=0)
+                resolution_input = gr.Textbox(label="Resolution", placeholder="Describe the resolution for the issue")
+                forked_repo_input = gr.Textbox(label="Forked Repo URL", placeholder="Enter the forked repository URL")
 
+            resolve_button = gr.Button("Resolve Issue")
             result_output = gr.Textbox(label="Result", interactive=False)
 
-        def on_analyze(token, repo_url, issue_number):
-            try:
-                parts = repo_url.split('/')
-                owner, repo = parts[-2], parts[-1]
-                
-                # Initialize bot
-                bot.initialize_api(token)
-                
-                # Get issue details
-                issue_url = f"{bot.github_api.base_url}/repos/{owner}/{repo}/issues/{issue_number}"
-                response = requests.get(issue_url, headers=bot.github_api.headers)
-                response.raise_for_status()
-                issue = response.json()
-                
-                # Determine severity
-                severity = bot._determine_severity(issue)
-                
-                return f"Issue Severity: {severity.name}"
-            except Exception as e:
-                return f"Error: {str(e)}"
-
-        def on_resolve(token, repo_url, ai_api_base, ai_api_key, issue_number, resolution, forked_repo):
-            try:
-                parts = repo_url.split('/')
-                owner, repo = parts[-2], parts[-1]
-                
-                # Initialize bot with AI provider
-                ai_provider = CustomAIProvider(ai_api_base, ai_api_key)
-                bot.initialize_api(token, ai_provider)
-                
-                result = bot.resolve_issue(token, owner, repo, int(issue_number), resolution, forked_repo)
-                return result
-            except Exception as e:
-                return f"Error: {str(e)}"
-
-        analyze_button.click(
-            on_analyze,
-            inputs=[token_input, repo_url_input, issue_number_input],
-            outputs=[severity_indicator]
-        )
+            resolve_button.click(
+                fn=on_resolve,
+                inputs=[token_input, repo_url_input, issue_number_input, resolution_input, forked_repo_input],
+                outputs=[result_output]
+            )
 
-        resolve_button.click(
-            on_resolve,
-            inputs=[token_input, repo_url_input, ai_api_base, ai_api_key, 
-                   issue_number_input, resolution_input, forked_repo_input],
-            outputs=[result_output]
-        )
+    return demo
 
-    return demo
+if __name__ == "__main__":
+    demo = create_gradio_interface()
+    demo.launch(server_name="0.0.0.0", server_port=7860)