Update app.py

app.py

@@ -19,8 +19,10 @@ LOGS_DIRECTORY = 'logs'
 RESOLUTIONS_DIRECTORY = 'resolutions'
 REPOS_DIRECTORY = 'repos'
 
-# Set up logging
+# Logger setup
 def initialize_logger() -> logging.Logger:
+    """Sets up and returns a logger instance."""
+    os.makedirs(LOGS_DIRECTORY, exist_ok=True)
     log_file = f"{LOGS_DIRECTORY}/github_bot_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
     logging.basicConfig(
         level=logging.INFO,
@@ -30,15 +32,19 @@ def initialize_logger() -> logging.Logger:
             logging.StreamHandler()
         ]
     )
-    return logging.getLogger(__name__)
+    return logging.getLogger("GitHubBot")
 
-# Initialize environment and logger
+# Global logger instance
+logger = initialize_logger()
+
+# Ensure required directories exist
 def initialize_environment():
+    """Creates necessary directories for the script."""
     directories = [LOGS_DIRECTORY, RESOLUTIONS_DIRECTORY, REPOS_DIRECTORY, INPUT_DIRECTORY, OUTPUT_DIRECTORY]
     for directory in directories:
         os.makedirs(directory, exist_ok=True)
 
-# GitHub API handler
+# GitHub API interaction
 class GitHubAPI:
     def __init__(self, token: str):
         self.token = token
@@ -49,6 +55,7 @@ class GitHubAPI:
         self.base_url = "https://api.github.com"
 
     def _check_rate_limit(self) -> bool:
+        """Checks the GitHub API rate limit and waits if necessary."""
         try:
             response = requests.get(f"{self.base_url}/rate_limit", headers=self.headers)
             response.raise_for_status()
@@ -59,416 +66,130 @@ class GitHubAPI:
             if remaining < 10:
                 wait_time = max(0, reset_time - int(time.time()))
                 if wait_time > 0:
-                    logger.warning(f"Rate limit nearly exceeded. Waiting {wait_time} seconds before retrying...")
+                    logger.warning(f"Rate limit nearly exceeded. Waiting {wait_time} seconds...")
                     time.sleep(wait_time)
                 return False
             return True
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Error checking rate limit: {str(e)}. Retrying...")
+        except requests.RequestException as e:
+            logger.error(f"Error checking rate limit: {str(e)}")
             return True
 
     def get_repository(self, owner: str, repo: str) -> Dict:
+        """Fetches repository details."""
         try:
             response = requests.get(f"{self.base_url}/repos/{owner}/{repo}", headers=self.headers)
             response.raise_for_status()
             return response.json()
         except requests.HTTPError as e:
-            logger.error(f"HTTP error getting repository info for {owner}/{repo}: {str(e)}. Please check the repository details.")
+            logger.error(f"HTTP error fetching repo {owner}/{repo}: {str(e)}")
             raise
         except Exception as e:
-            logger.error(f"Error getting repository info: {str(e)}")
+            logger.error(f"Error fetching repo: {str(e)}")
             raise
 
     def get_issues(self, owner: str, repo: str, state: str = 'open') -> List[Dict]:
+        """Fetches issues for a repository."""
         if not self._check_rate_limit():
             return []
 
         try:
-            response = requests.get(f"{self.base_url}/repos/{owner}/{repo}/issues", headers=self.headers, params={'state': state})
+            response = requests.get(
+                f"{self.base_url}/repos/{owner}/{repo}/issues",
+                headers=self.headers,
+                params={'state': state}
+            )
             response.raise_for_status()
-            issues = response.json()
-            return [issue for issue in issues if 'pull_request' not in issue]
-        except Exception as e:
-            logger.error(f"Error fetching issues for repository {owner}/{repo}: {str(e)}. Please verify the repository and token.")
+            return [issue for issue in response.json() if 'pull_request' not in issue]
+        except requests.RequestException as e:
+            logger.error(f"Error fetching issues for {owner}/{repo}: {str(e)}")
             return []
 
-# GitHub Bot
+# GitHub Bot main functionality
 class GitHubBot:
     def __init__(self):
         self.github_api = None
 
     def initialize_api(self, token: str):
+        """Initializes the GitHub API client."""
         self.github_api = GitHubAPI(token)
 
     def fetch_issues(self, token: str, owner: str, repo: str) -> List[Dict]:
-        try:
-            self.initialize_api(token)
-            return self.github_api.get_issues(owner, repo)
-        except Exception as e:
-            logger.error(f"Error fetching issues for repository {owner}/{repo}: {str(e)}")
-            return []
+        """Fetches issues from a repository."""
+        self.initialize_api(token)
+        return self.github_api.get_issues(owner, repo)
 
     def resolve_issue(self, token: str, owner: str, repo: str, issue_number: int, resolution: str, forked_repo: str) -> str:
+        """Resolves a GitHub issue and pushes changes to a forked repository."""
         try:
             self.initialize_api(token)
             self.github_api.get_repository(owner, repo)
 
-            # Create resolution file
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             resolution_file = f"{RESOLUTIONS_DIRECTORY}/resolution_{issue_number}_{timestamp}.md"
 
             with open(resolution_file, "w") as f:
                 f.write(f"# Resolution for Issue #{issue_number}\n\n{resolution}")
 
-            # Clone the forked repo
-            subprocess.run(['git', 'clone', forked_repo, '/tmp/' + forked_repo.split('/')[-1]], check=True)
+            temp_repo_dir = f"/tmp/{forked_repo.split('/')[-1]}"
+            subprocess.run(['git', 'clone', forked_repo, temp_repo_dir], check=True)
+            os.chdir(temp_repo_dir)
 
-            # Change to the cloned directory
-            os.chdir('/tmp/' + forked_repo.split('/')[-1])
+            input("Apply the fix manually, then press ENTER to continue...")
 
-            # Assuming manual intervention now
-            input("Apply the fix manually and stage the changes (press ENTER)? ")
-
-            # Commit and push the modifications
             subprocess.run(['git', 'add', '.'], check=True)
-            subprocess.run(['git', 'commit', '-m', f"Resolved issue #{issue_number} ({quote(resolution)})"], check=True)
+            subprocess.run(['git', 'commit', '-m', f"Resolved issue #{issue_number}: {resolution}"], check=True)
             subprocess.run(['git', 'push', 'origin', 'HEAD'], check=True)
 
-            # Open Pull Request page
-            webbrowser.open(f'https://github.com/{forked_repo.split("/")[-1]}/compare/master...{owner}:{forked_repo.split("/")[-1]}_resolved_issue_{issue_number}')
+            pull_request_url = f"https://github.com/{forked_repo.split('/')[-1]}/compare/master...{owner}:{repo}_resolved_issue_{issue_number}"
+            webbrowser.open(pull_request_url)
 
-            return f"Resolution saved: {resolution_file}"
+            return f"Resolution completed and saved: {resolution_file}"
 
         except Exception as e:
-            error_msg = f"Error resolving issue #{issue_number} in repository {owner}/{repo}: {str(e)}"
-            logger.error(error_msg)
-            return error_msg
-
-def handle_issue_selection(token, owner, repo, issue_number, resolution, forked_repo):
-    bot = GitHubBot()
-    result = bot.resolve_issue(token, owner, repo, issue_number, resolution, forked_repo)
-    return result
+            logger.error(f"Error resolving issue #{issue_number} for {owner}/{repo}: {str(e)}")
+            return f"Error resolving issue: {str(e)}"
 
+# Utility Functions
 def extract_info_from_url(url: str) -> Dict[str, Any]:
+    """Extracts information from a URL."""
     info = {}
     try:
         response = requests.get(url)
         response.raise_for_status()
         info['status_code'] = response.status_code
         info['headers'] = dict(response.headers)
-        info['content'] = response.text[:500]  # Limit content to first 500 characters for brevity
-
+        info['content'] = response.text[:500]
         parsed_url = urlparse(url)
+
         if 'github.com' in parsed_url.netloc:
-            parts = parsed_url.path.split('/')
-            if len(parts) > 2:
-                owner = parts[1]
-                repo = parts[2]
+            parts = parsed_url.path.strip('/').split('/')
+            if len(parts) >= 2:
+                owner, repo = parts[:2]
+                bot = GitHubBot()
                 issues = bot.fetch_issues(github_token, owner, repo)
                 info['issues'] = issues
-        elif 'huggingface.co' in parsed_url.netloc:
-            # Add Hugging Face specific handling if needed
-            pass
-
-    except requests.HTTPError as e:
-        info['error'] = f"HTTP error: {str(e)}"
-    except Exception as e:
-        info['error'] = f"Error: {str(e)}"
+    except requests.RequestException as e:
+        info['error'] = f"Error extracting info: {str(e)}"
     return info
 
-# Initialize GitHubBot globally
-bot = GitHubBot()
+# Initialize environment
+initialize_environment()
 
-# Define missing functions with validation
-def fetch_issues(token, repo_url):
-    try:
-        parts = repo_url.split('/')
-        if len(parts) < 2:
-            raise ValueError("Repository URL is not in the correct format. Expected format: 'owner/repo'.")
-
-        owner, repo = parts[-2], parts[-1]
-        issues = bot.fetch_issues(token, owner, repo)
-        return issues
-    except Exception as e:
-        return str(e)
-
-def resolve_issue(token, repo_url, issue_number, resolution, forked_repo_url):
-    try:
-        parts = repo_url.split('/')
-        if len(parts) < 2:
-            raise ValueError("Repository URL is not in the correct format. Expected format: 'owner/repo'.")
-
-        owner, repo = parts[-2], parts[-1]
-        result = bot.resolve_issue(token, owner, repo, issue_number, resolution, forked_repo_url)
-        return result
-    except Exception as e:
-        return str(e)
-
-def extract_info(url):
-    try:
-        info = extract_info_from_url(url)
-        return info
-    except Exception as e:
-        return str(e)
-
-# HTML and CSS integration
-custom_html = """
-<!DOCTYPE html>
-<html>
-<head>
-    <title>GitHub Issue Manager</title>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/tailwind.min.css" rel="stylesheet">
-    <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/full.css" rel="stylesheet" type="text/css" />
-    <style>
-        body {
-            background: linear-gradient(to bottom right, #121212, #303030) !important;
-            color: #e0e0e0;
-            font-family: 'Roboto', sans-serif;
-            overflow-x: hidden; /* Prevent horizontal scrollbar */
-        }
-        .card {
-            border-radius: 1.5rem;
-            box-shadow: 0 15px 25px rgba(0, 0, 0, 0.2);
-            margin-bottom: 20px;
-        }
-        .input, .select, .textarea {
-            border: 2px solid #4a4a4a;
-            border-radius: 0.75rem;
-            padding-inline: 1.5rem;
-            padding-block: 0.75rem;
-        }
-        h1, h2, h3 {
-            color: #e0e0e0;
-        }
-        .output-area {
-            padding: 1.5rem;
-            border-radius: 0.75rem;
-        }
-        .btn {
-            border-radius: 0.75rem;
-            padding-block: 0.75rem;
-            padding-inline: 1.5rem;
-        }
-        .btn-primary {
-            background-color: #7928CA;
-            color: white;
-            border: 2px solid #7928CA;
-        }
-        .btn-primary:hover {
-            background-color: #5e22a1;
-        }
-        .btn-success {
-            background-color: #22c55e;
-            color: white;
-            border: 2px solid #22c55e;
-        }
-        .btn-success:hover {
-            background-color: #1a9a46;
-        }
-    </style>
-</head>
-<body class="bg-gray-900">
-<div class="container mx-auto p-4">
-    <h1 class="text-4xl md:text-5xl font-extrabold text-center mb-8">GitHub Issue Manager</h1>
-    <!-- GitHub Token & Repo URL -->
-    <div class="card bg-gray-800 p-8">
-        <div class="form-control">
-            <label class="label">
-                <span class="label-text">GitHub Token</span>
-            </label>
-            <input type="password" placeholder="Enter your GitHub Personal Access Token" class="input input-bordered input-primary" id="github-token">
-        </div>
-        <div class="form-control">
-            <label class="label">
-                <span class="label-text">Repository URL</span>
-            </label>
-            <input type="text" placeholder="Enter the full GitHub repository URL" class="input input-bordered input-primary" id="repo-url">
-        </div>
-    </div>
-    <!-- Fetch & Resolve Section -->
-    <div class="card bg-gray-800 p-8">
-        <div class="flex justify-between gap-4">
-            <button class="btn btn-primary" id="fetch-issues">Fetch Issues</button>
-            <select class="select select-primary w-full max-w-xs" id="issue-dropdown">
-                <option disabled selected>Select Issue</option>
-            </select>
-        </div>
-        <div class="form-control mt-4">
-            <label class="label">
-                <span class="label-text">Resolution</span>
-            </label>
-            <textarea class="textarea textarea-primary" placeholder="Enter the resolution details" id="resolution-textarea"></textarea>
-        </div>
-        <div class="form-control mt-4">
-            <label class="label">
-                <span class="label-text">Forked Repository URL</span>
-            </label>
-            <input type="text" placeholder="URL to your forked repository (Optional)" class="input input-bordered input-primary" id="forked-repo-url">
-        </div>
-        <div class="form-control mt-4">
-            <button class="btn btn-success" id="resolve-issue">Resolve Issue</button>
-        </div>
-    </div>
-    <!-- Output Area -->
-    <div class="card bg-gray-800 p-8 mt-4">
-        <label class="label">
-            <span class="label-text">Output</span>
-        </label>
-        <textarea class="textarea textarea-primary h-48" id="output-textarea" readonly></textarea>
-    </div>
-    <!-- URL to Extract -->
-    <div class="card bg-gray-800 p-8 mt-4">
-        <div class="form-control">
-            <label class="label">
-                <span class="label-text">URL</span>
-            </label>
-            <input type="text" placeholder="Enter a URL to extract information" class="input input-bordered input-primary" id="url-textbox">
-        </div>
-        <div class="form-control">
-            <button class="btn btn-primary" id="extract-info">Extract Info</button>
-        </div>
-    </div>
-</div>
-<script>
-    const githubTokenInput = document.getElementById('github-token');
-    const repoUrlInput = document.getElementById('repo-url');
-    const fetchIssuesButton = document.getElementById('fetch-issues');
-    const issueDropdown = document.getElementById('issue-dropdown');
-    const resolutionTextarea = document.getElementById('resolution-textarea');
-    const forkedRepoUrlInput = document.getElementById('forked-repo-url');
-    const resolveIssueButton = document.getElementById('resolve-issue');
-    const outputTextarea = document.getElementById('output-textarea');
-    const urlTextbox = document.getElementById('url-textbox');
-    const extractInfoButton = document.getElementById('extract-info');
-
-    fetchIssuesButton.addEventListener('click', async () => {
-        const token = githubTokenInput.value;
-        const repoUrl = repoUrlInput.value;
-        if (!token || !repoUrl) {
-            outputTextarea.value = "Please provide both GitHub Token and Repository URL.";
-            return;
-        }
-        try {
-            const response = await fetch('/fetch-issues', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ githubToken: token, repoUrl: repoUrl }),
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const data = await response.json();
-            if (data.error) {
-                outputTextarea.value = data.error;
-            } else {
-                issueDropdown.innerHTML = '';
-                data.issues.forEach(issue => {
-                    const option = document.createElement('option');
-                    option.value = issue.number;
-                    option.text = `${issue.number}: ${issue.title}`;
-                    issueDropdown.add(option);
-                });
-            }
-        } catch (error) {
-            outputTextarea.value = `Error fetching issues: ${error.message}`;
-        }
-    });
-
-    resolveIssueButton.addEventListener('click', async () => {
-        const token = githubTokenInput.value;
-        const repoUrl = repoUrlInput.value;
-        const issueNumber = issueDropdown.value;
-        const resolution = resolutionTextarea.value;
-        const forkedRepoUrl = forkedRepoUrlInput.value;
-        if (!token || !repoUrl || !issueNumber || !resolution) {
-            outputTextarea.value = "Please provide all required fields.";
-            return;
-        }
-        try {
-            const response = await fetch('/resolve-issue', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ githubToken: token, repoUrl: repoUrl, issueNumber: issueNumber, resolution: resolution, forkedRepoUrl: forkedRepoUrl }),
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const data = await response.json();
-            if (data.error) {
-                outputTextarea.value = data.error;
-            } else {
-                outputTextarea.value = data.output;
-            }
-        } catch (error) {
-            outputTextarea.value = `Error resolving issue: ${error.message}`;
-        }
-    });
-
-    extractInfoButton.addEventListener('click', async () => {
-        const url = urlTextbox.value;
-        if (!url) {
-            outputTextarea.value = "Please provide a URL.";
-            return;
-        }
-        try {
-            const response = await fetch('/extract-info', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ url: url }),
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const data = await response.json();
-            if (data.error) {
-                outputTextarea.value = data.error;
-            } else {
-                outputTextarea.value = JSON.stringify(data, null, 2);
-            }
-        } catch (error) {
-            outputTextarea.value = `Error extracting info: ${error.message}`;
-        }
-    });
-</script>
-</body>
-</html>
-"""
-
-def create_gradio_interface():
-    with gr.Blocks(css=None, theme=None) as demo:
-        gr.HTML(custom_html)
-    return demo
-
-# Cleanup function
-def cleanup():
-    try:
-        temp_dirs = [REPOS_DIRECTORY]
-        for dir_name in temp_dirs:
-            if os.path.exists(dir_name):
-                shutil.rmtree(dir_name)
-        logging.shutdown()
-    except Exception as e:
-        print(f"Error during cleanup: {str(e)}")
-
-def main():
-    # Initialize environment and logger
-    initialize_environment()
-    logger = initialize_logger()
-
-    # Register cleanup handlers
-    atexit.register(cleanup)
+# Example usage (placeholder for main logic)
+if __name__ == "__main__":
+    print("GitHub Bot initialized. Add main logic as needed.")
 
-    # Create Gradio interface
-    demo = create_gradio_interface()
-    demo.launch()
+    # Sample interaction for testing purposes
+    token = input("Enter your GitHub Personal Access Token: ").strip()
+    owner = input("Enter the repository owner: ").strip()
+    repo = input("Enter the repository name: ").strip()
 
-if __name__ == "__main__":
-    main()
+    bot = GitHubBot()
+    issues = bot.fetch_issues(token, owner, repo)
+
+    if issues:
+        print(f"Found {len(issues)} issue(s):")
+        for issue in issues:
+            print(f"- #{issue['number']}: {issue['title']}")
+    else:
+        print("No issues found or unable to fetch issues.")