Update app.py

app.py

@@ -1,226 +1,102 @@
 import gradio as gr
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
-from sentence_transformers import SentenceTransformer, util
+import subprocess
 import os
-import requests
-from huggingface_hub import HfApi, HfFolder
-import openai
-
-client = openai.OpenAI()
-
-# Constants
-GITHUB_API_BASE_URL = "https://api.github.com/repos"
-DEFAULT_MODEL = "acecalisto3/PhiCoDInstruck"
-MAX_RELATED_ISSUES = 3
-
-# Initialize global variables
-model = None
-tokenizer = None
-similarity_model = SentenceTransformer('all-MiniLM-L6-v2')
-
-def load_model(hf_token):
-    """Loads the model and tokenizer using the provided Hugging Face token."""
-    global model, tokenizer
-
-    # Set the token for Hugging Face authentication
-    HfApi().set_access_token(hf_token)
-    HfFolder.save_token(hf_token)  # Save the token to a file
-
-    # Load the model
-    model = AutoModelForCausalLM.from_pretrained(DEFAULT_MODEL)
-    tokenizer = AutoTokenizer.from_pretrained(DEFAULT_MODEL)
-
-    # Cache the model and tokenizer for future use (optional)
-    # model.save_pretrained("model")
-    # tokenizer.save_pretrained("tokenizer")
-
-    return "Model loaded successfully!"
-
-def analyze_issues(issue_text: str, severity: str = None, programming_language: str = None) -> dict:
-    """Analyzes issues and provides solutions using a specified language model."""
-    global model, tokenizer
-
-    if model is not None and tokenizer is not None:
-        response = model.generate(
-            tokenizer(f"{issue_text}\nAssistant: ", return_tensors="pt")['input_ids'],
-            max_length=2048,
-            do_sample=True,
-            temperature=0.7,
-            top_k=50,
-        )
-        assistant_response = tokenizer.batch_decode(response, skip_special_tokens=True)[0].strip()
-
-        # Extract severity and programming language from the response
-        if "Severity" in assistant_response:
-            severity = assistant_response.split(":")[1].strip()
-        if "Programming Language" in assistant_response:
-            programming_language = assistant_response.split(":")[1].strip()
-
-        return {
-            'assistant_response': assistant_response,
-            'severity': severity,
-            'programming_language': programming_language,
-        }
-    else:
-        return {"assistant_response": "Please enter your Hugging Face API token and click 'Load Model'."}
-
-def find_related_issues(issue_text: str, issues: list) -> list:
-    """Finds semantically related issues from a list of issues based on the input issue text."""
-    issue_embedding = similarity_model.encode(issue_text, convert_to_tensor=True)
-    similarities = [util.cos_sim(issue_embedding, similarity_model.encode(issue['title'], convert_to_tensor=True)) for issue in issues]
-    sorted_issues = sorted(enumerate(similarities), key=lambda x: x[1], reverse=True)
-    related_issues = [issues[i] for i, similarity in sorted_issues[:MAX_RELATED_ISSUES]]
-    return related_issues
-
-def fetch_github_issues(github_api_token: str, github_username: str, github_repository: str) -> list:
-    """Fetches issues from a specified GitHub repository using the GitHub API."""
-    headers = {'Authorization': f'token {github_api_token}'}
-    url = f"{GITHUB_API_BASE_URL}/{github_username}/{github_repository}/issues"
-    response = requests.get(url, headers=headers)
-    issues = response.json()
-    return issues
-
-def respond(command, history, system_message, max_tokens, temperature, top_p, github_api_token, github_username, github_repository, *args, **kwargs):
-    """Handles user commands and generates responses using the selected language model."""
-    global model, tokenizer
-
-    command = command.strip()
-
-    if model is not None and tokenizer is not None:
-        response = model.generate(
-            tokenizer(f"{system_message}\n{command}\n{history}\n{github_username}/{github_repository}\nAssistant: ", return_tensors="pt")['input_ids'],
-            max_length=max_tokens,
-            do_sample=True,
-            temperature=temperature,
-            top_k=top_p,
-        )
-        assistant_response = tokenizer.batch_decode(response, skip_special_tokens=True)[0].strip() if response else ''
-        return {
-            'assistant_response': assistant_response,
-        }
-    else:
-        return {"assistant_response": "Please enter your Hugging Face API token and click 'Load Model'."}
-
-class MyChatbot(gr.Chatbot):
-    """Custom Chatbot class for enhanced functionality."""
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.issues = []  # Store fetched issues
-        self.current_issue = None  # Store the currently selected issue
-
-    def postprocess(self, y):
-        """Post-processes the response to handle commands and display results."""
-        # Ensure `y` is not None
-        if y is None:
-            return "No response available."
-
-        # Extract the response from the dictionary
-        assistant_response = y.get('assistant_response', "No response available.")
-        command = y.get('command', "")
-
-        # Handle commands
-        if command == "/github":
-            if not y['github_api_token']:
-                return "Please enter your GitHub API token first."
-            else:
-                try:
-                    self.issues = fetch_github_issues(y['github_api_token'], y['github_username'], y['github_repository'])
-                    issue_list = "\n".join([f"{i+1}. {issue['title']}" for i, issue in enumerate(self.issues)])
-                    return f"Available GitHub Issues:\n{issue_list}\n\nEnter the issue number to analyze:"
-                except Exception as e:
-                    return f"Error fetching GitHub issues: {e}"
-        elif command == "/help":
-            return """Available commands:
-                - `/github`: Analyze a GitHub issue
-                - `/help`: Show this help message
-                - `/generate_code [code description]`: Generate code based on the description
-                - `/explain_concept [concept]`: Explain a concept
-                - `/write_documentation [topic]`: Write documentation for a given topic
-                - `/translate_code [code] to [target language]`: Translate code to another language"""
-        elif command.isdigit() and self.issues:
-            try:
-                issue_number = int(command) - 1
-                if 0 <= issue_number < len(self.issues):
-                    self.current_issue = self.issues[issue_number]
-                else:
-                    return "Invalid issue number."
-
-                # Store the selected issue
-                issue_text = self.current_issue['title'] + "\n\n" + self.current_issue['body']
-                resolution = analyze_issues(issue_text)
-                related_issues = find_related_issues(issue_text, self.issues)
-                related_issue_text = "\n".join([f"- {issue['title']} (Similarity: {similarity:.2f})" for issue, similarity in related_issues])
-                return f"Resolution for Issue '{self.current_issue['title']}':\n{resolution['assistant_response']}\n\nRelated Issues:\n{related_issue_text}"
-            except Exception as e:
-                return f"Error analyzing issue: {e}"
-        elif command.startswith("/"):
-            # Handle commands like `/generate_code`, `/explain_concept`, etc.
-            if self.current_issue:
-                # Use the current issue's context for these commands
-                issue_text = self.current_issue['title'] + "\n\n" + self.current_issue['body']
-                return analyze_issues(issue_text)['assistant_response']
-            else:
-                return "Please select an issue first using `/github`."
-        else:
-            # For free-form text, simply display the assistant's response
-            return assistant_response
-
-def setup_demo():
-    with gr.Blocks() as demo:
-        with gr.Row():
-            hf_token = gr.Textbox(placeholder="Enter Hugging Face API Token", type="password")
-            github_api_token = gr.Textbox(placeholder="Enter GitHub API Token", type="password")
-            github_username = gr.Textbox(placeholder="Enter GitHub Username")
-            github_repository = gr.Textbox(placeholder="Enter GitHub Repository")
-
-        system_message = gr.Textbox(
-            value="You are GitBot, the Github project guardian angel. You resolve issues and propose implementation of feature requests.",
-            label="System message"
-        )
-
-        # Load the model when the token is entered
-        load_button = gr.Button("Load Model")
-        status_box = gr.Textbox(label="Status")
-
-        load_button.click(fn=load_model, inputs=[hf_token], outputs=[status_box])
-
-        chatbot = MyChatbot()
-
-        # Add a command input
-        command = gr.Textbox(label="Command")
-
-        # Add sliders for model generation settings
-        max_tokens = gr.Slider(minimum=1, maximum=8192, value=2048, step=1, label="Max new tokens")
-        temperature = gr.Slider(minimum=0.1, maximum=4.0, value=0.71, step=0.1, label="Temperature")
-        top_p = gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.01, label="Top-p (nucleus sampling)")
-
-        # Set up the main interaction
-        respond_button = gr.Button("Respond")
-        respond_button.click(
-            fn=respond,
-            inputs=[
-                command,
-                gr.State(),  # history placeholder
-                system_message,
-                max_tokens,
-                temperature,
-                top_p,
-                github_api_token,
-                github_username,
-                github_repository,
-            ],
-            outputs=[chatbot]
-        )
-
-        # Add a button to fetch GitHub issues
-        fetch_issues_button = gr.Button("Fetch Issues")
-        fetch_issues_button.click(
-            fn=lambda github_api_token, github_username, github_repository: fetch_github_issues(github_api_token, github_username, github_repository),
-            inputs=[github_api_token, github_username, github_repository],
-            outputs=[gr.Dropdown(choices=[], label="Select Issue")]
-        )
-
-    return demo
-
-demo = setup_demo()
-setup_demo.launch()
+
+iface = gr.Blocks()
+
+with iface:
+    gr.Markdown("## Issue Resolution Workshop")
+    issue_number = gr.Number(label="Issue Number")
+    replicate_issue = gr.Button(label="Replicate Issue")
+    resolve_issue = gr.Button(label="Resolve Issue")
+    issue_description = gr.Markdown(label="Issue Description")
+    resolution_notes = gr.Markdown(label="Resolution Notes")
+    resolution_proof = gr.Markdown(label="Resolution Proof")
+    submit_resolution = gr.Button(label="Submit Resolution")
+
+# Set up GitPython
+os.environ["HOME"] = "/tmp"
+repo = Repo.init("/tmp/repo")
+
+# Authenticate with GitHub
+token = os.environ["GITHUB_TOKEN"]
+repo.config_writer().set_value("user", "token", token).release()
+
+# Pull issues from enricoros/big-agi
+issues_url = "https://api.github.com/repos/enricoros/big-agi/issues"
+issues = subprocess.check_output(["curl", "-s", issues_url]).decode().strip().split("\n")
+
+# Loop through the issues and store them in a dictionary
+issues_dict = {}
+for issue in issues:
+    issue = eval(issue)
+    title = issue["title"]
+    number = issue["number"]
+    issues_dict[number] = title
+
+# Define the replicate issue function
+def replicate_issue(number):
+    # Check if the issue number exists
+    if number not in issues_dict:
+        return "Issue not found"
+
+    # Clone your miagi fork
+    miagi_repo = Repo.clone_from("https://github.com/Ig0tU/miagi.git", "/tmp/miagi")
+
+    # Create a new branch for the issue
+    miagi_repo.create_head(f"issue-{number}", miagi_repo.head.reference)
+    miagi_branch = miagi_repo.heads[f"issue-{number}"]
+
+    # Checkout the new branch
+    miagi_branch.checkout()
+
+    # Replicate the issue in the new branch
+    shutil.copytree(os.path.expanduser("~/enricoros/big-agi/issues"), os.path.expanduser("~/miagi/issues"))
+
+    # Update the issue description
+    issue_description.update(issues_dict[number])
+
+    return "Issue replicated"
+
+# Define the resolve issue function
+def resolve_issue(number):
+    # Check if the issue number exists
+    if number not in issues_dict:
+        return "Issue not found"
+
+    # Resolve the issue in the new branch
+    # (Replace this with your own code to resolve the issue)
+    with open(os.path.expanduser("~/miagi/issues/{}/{}.md".format(number, number)), "a") as f:
+        f.write("Resolved!\n\n")
+
+    return "Issue resolved"
+
+# Define the submit resolution function
+def submit_resolution(number):
+    # Check if the issue number exists
+    if number not in issues_dict:
+        return "Issue not found"
+
+    # Document the resolution in a README file
+    with open(os.path.expanduser("~/miagi/README.md"), "a") as f:
+        f.write(f"Issue {number}: {issues_dict[number]}\n")
+        f.write("--------------------\n")
+        f.write(open(os.path.expanduser("~/miagi/issues/{}/{}.md".format(number, number))).read())
+        f.write("\n\n")
+
+    # Commit and push the changes
+    miagi_repo = Repo.init("/tmp/miagi")
+    miagi_repo.git.add(".")
+    miagi_repo.git.commit(m="Resolved issue {}".format(number))
+    miagi_repo.git.push()
+
+    return "Resolution submitted"
+iface.replicate_issue.output.subscribe(issue_description.update)
+iface.resolve_issue.output.subscribe(resolution_notes.update)
+iface.submit_resolution.output.subscribe(lambda _: "Resolution submitted")
+
+iface.connect(lambda number: replicate_issue(number), "Number")
+iface.connect(lambda _: resolve_issue(issue_number.output.value), "Resolve Issue")
+iface.connect(lambda _: submit_resolution(issue_number.output.value), "Submit Resolution")
+
+iface.launch()