Update app.py

app.py

@@ -1,317 +1,284 @@
-import streamlit as st
-import os
-import subprocess
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
-import black
-from pylint import lint
-from io import StringIO
-# import openai  # We're not using OpenAI anymore
-import sys
-
-# Set your Hugging Face API key here
-HF_API_KEY = "YOUR_HUGGING_FACE_API_KEY"
-
-PROJECT_ROOT = "projects"
-AGENT_DIRECTORY = "agents"
-
-# Global state to manage communication between Tool Box and Workspace Chat App
-if 'chat_history' not in st.session_state:
-    st.session_state.chat_history = []
-if 'terminal_history' not in st.session_state:
-    st.session_state.terminal_history = []
-if 'workspace_projects' not in st.session_state:
-    st.session_state.workspace_projects = {}
-if 'available_agents' not in st.session_state:
-    st.session_state.available_agents = []
-
-class AIAgent:
-    def __init__(self, name, description, skills):
-        self.name = name
-        self.description = description
-        self.skills = skills
-
-    def create_agent_prompt(self):
-        skills_str = '\n'.join([f"* {skill}" for skill in self.skills])
-        agent_prompt = f"""
-As an elite expert developer, my name is {self.name}. I possess a comprehensive understanding of the following areas:
-{skills_str}
-
-I am confident that I can leverage my expertise to assist you in developing and deploying cutting-edge web applications. Please feel free to ask any questions or present any challenges you may encounter.
-"""
-        return agent_prompt
-
-    def autonomous_build(self, chat_history, workspace_projects):
-        """
-        Autonomous build logic that continues based on the state of chat history and workspace projects.
-        """
-        # Example logic: Generate a summary of chat history and workspace state
-        summary = "Chat History:\n" + "\n".join([f"User: {u}\nAgent: {a}" for u, a in chat_history])
-        summary += "\n\nWorkspace Projects:\n" + "\n".join([f"{p}: {details}" for p, details in workspace_projects.items()])
-
-        # Example: Generate the next logical step in the project
-        next_step = "Based on the current state, the next logical step is to implement the main application logic."
-
-        return summary, next_step
-
-def save_agent_to_file(agent):
-    """Saves the agent's prompt to a file."""
-    if not os.path.exists(AGENT_DIRECTORY):
-        os.makedirs(AGENT_DIRECTORY)
-    file_path = os.path.join(AGENT_DIRECTORY, f"{agent.name}.txt")
-    with open(file_path, "w") as file:
-        file.write(agent.create_agent_prompt())
-    st.session_state.available_agents.append(agent.name)
-
-def load_agent_prompt(agent_name):
-    """Loads an agent prompt from a file."""
-    file_path = os.path.join(AGENT_DIRECTORY, f"{agent_name}.txt")
-    if os.path.exists(file_path):
-        with open(file_path, "r") as file:
-            agent_prompt = file.read()
-        return agent_prompt
+import requests
+from bs4 import BeautifulSoup
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+from nltk.tokenize import word_tokenize
+from gensim.models import LdaModel
+from gensim.corpora import Dictionary
+from textblob import TextBlob
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+import networkx as nx
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import accuracy_score, classification_report, roc_auc_score
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import Pipeline
+from sklearn.feature_extraction.text import TfidfVectorizer
+import plotly.graph_objects as go
+from collections import Counter
+import warnings
+warnings.filterwarnings("ignore")
+
+# Set up logging
+import logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Function to fetch HTML content from GitHub issue pages
+def fetch_issue_data(username, repository, start_page, end_page):
+    issues_data = []
+    for page in range(start_page, end_page + 1):
+        url = f"https://github.com/{username}/{repository}/issues?page={page}"
+        response = requests.get(url)
+        soup = BeautifulSoup(response.content, 'html.parser')
+        issue_elements = soup.find_all('div', class_='flex-shrink-0')
+        for issue_element in issue_elements:
+            issue_link = issue_element.find('a', class_='Link--primary')['href']
+            issue_url = f"https://github.com{issue_link}"
+            issue_data = fetch_issue_details(issue_url)
+            issues_data.append(issue_data)
+    return issues_data
+
+# Function to fetch details of a specific issue
+def fetch_issue_details(issue_url):
+    response = requests.get(issue_url)
+    soup = BeautifulSoup(response.content, 'html.parser')
+    issue_title = soup.find('h1', class_='gh-header-title').text.strip()
+    issue_body = soup.find('div', class_='markdown-body').text.strip()
+    issue_created_at = soup.find('relative-time')['datetime']
+    issue_closed_at = soup.find('relative-time', class_='no-wrap')
+    if issue_closed_at:
+        issue_closed_at = issue_closed_at['datetime']
     else:
-        return None
-
-def create_agent_from_text(name, text):
-    skills = text.split('\n')
-    agent = AIAgent(name, "AI agent created from text input.", skills)
-    save_agent_to_file(agent)
-    return agent.create_agent_prompt()
-
-# Chat interface using a selected agent (Hugging Face version)
-def chat_interface_with_agent(input_text, agent_name):
-    agent_prompt = load_agent_prompt(agent_name)
-    if agent_prompt is None:
-        return f"Agent {agent_name} not found."
-
-    # Use a Hugging Face model for chat with the agent
-    # Example: Using the 'google/flan-t5-xl' model
-    generator = pipeline("text-generation", model="google/flan-t5-xl", use_auth_token=HF_API_KEY)
-
-    # Combine the agent prompt with user input
-    combined_input = f"{agent_prompt}\n\nUser: {input_text}\nAgent:"
-
-    # Generate chatbot response
-    response = generator(combined_input, max_length=150, num_return_sequences=1, do_sample=True)
-    return response[0]['generated_text']
-
-# Terminal interface
-def terminal_interface(command, project_name=None):
-    if project_name:
-        project_path = os.path.join(PROJECT_ROOT, project_name)
-        result = subprocess.run(command, shell=True, capture_output=True, text=True, cwd=project_path)
+        issue_closed_at = None
+    issue_author = soup.find('a', class_='author').text.strip()
+    issue_assignee = soup.find('a', class_='Link--muted')
+    if issue_assignee:
+        issue_assignee = issue_assignee.text.strip()
     else:
-        result = subprocess.run(command, shell=True, capture_output=True, text=True)
-    return result.stdout
-
-# Code editor interface
-def code_editor_interface(code):
-    formatted_code = black.format_str(code, mode=black.FileMode())
-    pylint_output = lint.Run([formatted_code], do_exit=False)
-    pylint_output_str = StringIO()
-    pylint_output.linter.reporter.write_messages(pylint_output_str)
-    return formatted_code, pylint_output_str.getvalue()
-
-# Text summarization tool
-def summarize_text(text):
-    summarizer = pipeline("summarization", model="facebook/bart-large-cnn", use_auth_token=HF_API_KEY)
-    summary = summarizer(text, max_length=130, min_length=30, do_sample=False)
-    return summary[0]['summary_text']
-
-# Sentiment analysis tool
-def sentiment_analysis(text):
-    analyzer = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-3-literal", use_auth_token=HF_API_KEY)
-    result = analyzer(text)
-    return result[0]['label']
-
-# Text translation tool (code translation)
-def translate_code(code, source_language, target_language):
-    # Placeholder for translation logic
-    return f"Translated {source_language} code to {target_language}."
-
-# Code generation tool
-def generate_code(idea):
-    # Use a Hugging Face model for code generation
-    # Example: Using the 'Salesforce/codet5-base' model
-    generator = pipeline("text-generation", model="Salesforce/codet5-base", use_auth_token=HF_API_KEY)
-    response = generator(idea, max_length=150, num_return_sequences=1, do_sample=True)
-    return response[0]['generated_text']
-
-# Workspace interface
-def workspace_interface(project_name):
-    project_path = os.path.join(PROJECT_ROOT, project_name)
-    if not os.path.exists(project_path):
-        os.makedirs(project_path)
-        st.session_state.workspace_projects[project_name] = {'files': []}
-        return f"Project '{project_name}' created successfully."
-    else:
-        return f"Project '{project_name}' already exists."
-
-# Add code to workspace
-def add_code_to_workspace(project_name, code, file_name):
-    project_path = os.path.join(PROJECT_ROOT, project_name)
-    if not os.path.exists(project_path):
-        return f"Project '{project_name}' does not exist."
-    
-    file_path = os.path.join(project_path, file_name)
-    with open(file_path, "w") as file:
-        file.write(code)
-    st.session_state.workspace_projects[project_name]['files'].append(file_name)
-    return f"Code added to '{file_name}' in project '{project_name}'."
-
-# Chat interface (Hugging Face version)
-def chat_interface(input_text):
-    # Use a Hugging Face model for chat
-    # Example: Using the 'google/flan-t5-xl' model
-    generator = pipeline("text-generation", model="google/flan-t5-xl", use_auth_token=HF_API_KEY)
-    response = generator(input_text, max_length=150, num_return_sequences=1, do_sample=True)
-    return response[0]['generated_text']
-
-# Streamlit App
-st.title("AI Agent Creator")
-
-# Sidebar navigation
-st.sidebar.title("Navigation")
-app_mode = st.sidebar.selectbox("Choose the app mode", ["AI Agent Creator", "Tool Box", "Workspace Chat App"])
-
-if app_mode == "AI Agent Creator":
-    # AI Agent Creator
-    st.header("Create an AI Agent from Text")
-
-    st.subheader("From Text")
-    agent_name = st.text_input("Enter agent name:")
-    text_input = st.text_area("Enter skills (one per line):")
-    if st.button("Create Agent"):
-        agent_prompt = create_agent_from_text(agent_name, text_input)
-        st.success(f"Agent '{agent_name}' created and saved successfully.")
-        st.session_state.available_agents.append(agent_name)
-
-elif app_mode == "Tool Box":
-    # Tool Box
-    st.header("AI-Powered Tools")
-
-    # Chat Interface
-    st.subheader("Chat with CodeCraft")
-    chat_input = st.text_area("Enter your message:")
-    if st.button("Send"):
-        chat_response = chat_interface(chat_input)
-        st.session_state.chat_history.append((chat_input, chat_response))
-        st.write(f"CodeCraft: {chat_response}")
-
-    # Terminal Interface
-    st.subheader("Terminal")
-    terminal_input = st.text_input("Enter a command:")
-    if st.button("Run"):
-        terminal_output = terminal_interface(terminal_input)
-        st.session_state.terminal_history.append((terminal_input, terminal_output))
-        st.code(terminal_output, language="bash")
-
-    # Code Editor Interface
-    st.subheader("Code Editor")
-    code_editor = st.text_area("Write your code:", height=300)
-    if st.button("Format & Lint"):
-        formatted_code, lint_message = code_editor_interface(code_editor)
-        st.code(formatted_code, language="python")
-        st.info(lint_message)
-
-    # Text Summarization Tool
-    st.subheader("Summarize Text")
-    text_to_summarize = st.text_area("Enter text to summarize:")
-    if st.button("Summarize"):
-        summary = summarize_text(text_to_summarize)
-        st.write(f"Summary: {summary}")
-
-    # Sentiment Analysis Tool
-    st.subheader("Sentiment Analysis")
-    sentiment_text = st.text_area("Enter text for sentiment analysis:")
-    if st.button("Analyze Sentiment"):
-        sentiment = sentiment_analysis(sentiment_text)
-        st.write(f"Sentiment: {sentiment}")
-
-    # Text Translation Tool (Code Translation)
-    st.subheader("Translate Code")
-    code_to_translate = st.text_area("Enter code to translate:")
-    source_language = st.text_input("Enter source language (e.g., 'Python'):")
-    target_language = st.text_input("Enter target language (e.g., 'JavaScript'):")
-    if st.button("Translate Code"):
-        translated_code = translate_code(code_to_translate, source_language, target_language)
-        st.code(translated_code, language=target_language.lower())
-
-    # Code Generation
-    st.subheader("Code Generation")
-    code_idea = st.text_input("Enter your code idea:")
-    if st.button("Generate Code"):
-        generated_code = generate_code(code_idea)
-        st.code(generated_code, language="python")
-
-elif app_mode == "Workspace Chat App":
-    # Workspace Chat App
-    st.header("Workspace Chat App")
-
-    # Project Workspace Creation
-    st.subheader("Create a New Project")
-    project_name = st.text_input("Enter project name:")
-    if st.button("Create Project"):
-        workspace_status = workspace_interface(project_name)
-        st.success(workspace_status)
-
-    # Add Code to Workspace
-    st.subheader("Add Code to Workspace")
-    code_to_add = st.text_area("Enter code to add to workspace:")
-    file_name = st.text_input("Enter file name (e.g., 'app.py'):")
-    if st.button("Add Code"):
-        add_code_status = add_code_to_workspace(project_name, code_to_add, file_name)
-        st.success(add_code_status)
-
-    # Terminal Interface with Project Context
-    st.subheader("Terminal (Workspace Context)")
-    terminal_input = st.text_input("Enter a command within the workspace:")
-    if st.button("Run Command"):
-        terminal_output = terminal_interface(terminal_input, project_name)
-        st.code(terminal_output, language="bash")
-
-    # Chat Interface for Guidance
-    st.subheader("Chat with CodeCraft for Guidance")
-    chat_input = st.text_area("Enter your message for guidance:")
-    if st.button("Get Guidance"):
-        chat_response = chat_interface(chat_input)
-        st.session_state.chat_history.append((chat_input, chat_response))
-        st.write(f"CodeCraft: {chat_response}")
-
-    # Display Chat History
-    st.subheader("Chat History")
-    for user_input, response in st.session_state.chat_history:
-        st.write(f"User: {user_input}")
-        st.write(f"CodeCraft: {response}")
-
-    # Display Terminal History
-    st.subheader("Terminal History")
-    for command, output in st.session_state.terminal_history:
-        st.write(f"Command: {command}")
-        st.code(output, language="bash")
-
-    # Display Projects and Files
-    st.subheader("Workspace Projects")
-    for project, details in st.session_state.workspace_projects.items():
-        st.write(f"Project: {project}")
-        for file in details['files']:
-            st.write(f"  - {file}")
-
-    # Chat with AI Agents
-    st.subheader("Chat with AI Agents")
-    selected_agent = st.selectbox("Select an AI agent", st.session_state.available_agents)
-    agent_chat_input = st.text_area("Enter your message for the agent:")
-    if st.button("Send to Agent"):
-        agent_chat_response = chat_interface_with_agent(agent_chat_input, selected_agent)
-        st.session_state.chat_history.append((agent_chat_input, agent_chat_response))
-        st.write(f"{selected_agent}: {agent_chat_response}")
-
-    # Automate Build Process
-    st.subheader("Automate Build Process")
-    if st.button("Automate"):
-        agent = AIAgent(selected_agent, "", [])  # Load the agent without skills for now
-        summary, next_step = agent.autonomous_build(st.session_state.chat_history, st.session_state.workspace_projects)
-        st.write("Autonomous Build Summary:")
-        st.write(summary)
-        st.write("Next Step:")
-        st.write(next_step)
+        issue_assignee = None
+    return {
+        'title': issue_title,
+        'body': issue_body,
+        'created_at': issue_created_at,
+        'closed_at': issue_closed_at,
+        'author': issue_author,
+        'assignee': issue_assignee
+    }
+
+# Function to clean and structure the data
+def clean_and_structure_data(issues_data):
+    df = pd.DataFrame(issues_data)
+    df['created_at'] = pd.to_datetime(df['created_at'])
+    df['closed_at'] = pd.to_datetime(df['closed_at'])
+    df['resolution_time'] = (df['closed_at'] - df['created_at']).dt.days
+    df['resolution_time'] = df['resolution_time'].fillna(-1)
+    df['is_closed'] = (df['closed_at'].notna()).astype(int)
+    return df
+
+# Function for exploratory data analysis (EDA)
+def perform_eda(df):
+    # Descriptive statistics
+    print("Descriptive Statistics:")
+    print(df.describe())
+
+    # Visualizations
+    plt.figure(figsize=(10, 6))
+    sns.histplot(df['resolution_time'], kde=True)
+    plt.title('Distribution of Issue Resolution Time')
+    plt.xlabel('Resolution Time (Days)')
+    plt.ylabel('Frequency')
+    plt.show()
+
+    # Trend analysis
+    df['created_at_month'] = df['created_at'].dt.month
+    plt.figure(figsize=(10, 6))
+    sns.lineplot(x='created_at_month', y='resolution_time', data=df)
+    plt.title('Trend of Issue Resolution Time Over Months')
+    plt.xlabel('Month')
+    plt.ylabel('Resolution Time (Days)')
+    plt.show()
+
+    # Top Authors and Assignees
+    top_authors = df['author'].value_counts().nlargest(10)
+    top_assignees = df['assignee'].value_counts().nlargest(10)
+    print("\nTop 10 Authors:")
+    print(top_authors)
+    print("\nTop 10 Assignees:")
+    print(top_assignees)
+
+# Function for text analysis using NLP
+def analyze_text_content(df):
+    # Text preprocessing
+    stop_words = set(stopwords.words('english'))
+    lemmatizer = WordNetLemmatizer()
+    df['processed_body'] = df['body'].apply(lambda text: ' '.join([lemmatizer.lemmatize(word) for word in word_tokenize(text) if word.lower() not in stop_words]))
+
+    # Topic modeling
+    dictionary = Dictionary([word_tokenize(text) for text in df['processed_body']])
+    corpus = [dictionary.doc2bow(word_tokenize(text)) for text in df['processed_body']]
+    lda_model = LdaModel(corpus, num_topics=5, id2word=dictionary)
+    print("Top 5 Topics:")
+    for topic in lda_model.print_topics(num_words=5):
+        print(topic)
+
+    # Sentiment analysis
+    analyzer = SentimentIntensityAnalyzer()
+    df['sentiment'] = df['body'].apply(lambda text: analyzer.polarity_scores(text)['compound'])
+    print("Sentiment Analysis:")
+    print(df['sentiment'].describe())
+
+    # Word Cloud for Common Words
+    from wordcloud import WordCloud
+    all_words = ' '.join([text for text in df['processed_body']])
+    wordcloud = WordCloud(width=800, height=400, background_color='white').generate(all_words)
+    plt.figure(figsize=(10, 6), facecolor=None)
+    plt.imshow(wordcloud)
+    plt.axis("off")
+    plt.tight_layout(pad=0)
+    plt.show()
+
+# Function to create a network graph of issues, authors, and assignees
+def create_network_graph(df):
+    graph = nx.Graph()
+    for index, row in df.iterrows():
+        graph.add_node(row['title'], type='issue')
+        graph.add_node(row['author'], type='author')
+        if row['assignee']:
+            graph.add_node(row['assignee'], type='assignee')
+        graph.add_edge(row['title'], row['author'])
+        if row['assignee']:
+            graph.add_edge(row['title'], row['assignee'])
+
+    # Interactive Network Graph with Plotly
+    pos = nx.spring_layout(graph, k=0.5)
+    edge_x = []
+    edge_y = []
+    for edge in graph.edges():
+        x0, y0 = pos[edge[0]]
+        x1, y1 = pos[edge[1]]
+        edge_x.append([x0, x1, None])
+        edge_y.append([y0, y1, None])
+
+    edge_trace = go.Scatter(
+        x=edge_x,
+        y=edge_y,
+        line=dict(width=0.5, color='#888'),
+        hoverinfo='none',
+        mode='lines'
+    )
+
+    node_x = []
+    node_y = []
+    for node in graph.nodes():
+        x, y = pos[node]
+        node_x.append(x)
+        node_y.append(y)
+
+    node_trace = go.Scatter(
+        x=node_x,
+        y=node_y,
+        mode='markers',
+        marker=dict(
+            color=[],
+            size=10,
+            line=dict(width=2, color='black')
+        ),
+        text=[],
+        hoverinfo='text'
+    )
+
+    # Set node colors based on type
+    node_colors = []
+    for node in graph.nodes():
+        if graph.nodes[node]['type'] == 'issue':
+            node_colors.append('red')
+        elif graph.nodes[node]['type'] == 'author':
+            node_colors.append('blue')
+        else:
+            node_colors.append('green')
+
+    # Set node labels
+    node_labels = []
+    for node in graph.nodes():
+        node_labels.append(node)
+
+    node_trace.marker.color = node_colors
+    node_trace.text = node_labels
+
+    # Create the figure
+    fig = go.Figure(data=[edge_trace, node_trace],
+                   layout=go.Layout(
+                       title="GitHub Issue Network Graph",
+                       showlegend=False,
+                       hovermode='closest',
+                       margin=dict(b=20, l=5, r=5, t=40),
+                       xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                       yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
+                   )
+                  )
+
+    fig.show()
+
+# Function to build a predictive model for issue resolution time
+def build_predictive_model(df):
+    # Feature engineering
+    df['created_at_day'] = df['created_at'].dt.day
+    df['created_at_weekday'] = df['created_at'].dt.weekday
+    df['created_at_hour'] = df['created_at'].dt.hour
+    df['author_encoded'] = df['author'].astype('category').cat.codes
+    df['assignee_encoded'] = df['assignee'].astype('category').cat.codes
+
+    # Select features and target variable
+    features = ['created_at_day', 'created_at_weekday', 'created_at_hour', 'author_encoded', 'assignee_encoded', 'sentiment']
+    target = 'resolution_time'
+
+    # Split data into training and testing sets
+    X_train, X_test, y_train, y_test = train_test_split(df[features], df[target], test_size=0.2, random_state=42)
+
+    # Create a pipeline for feature scaling and model training
+    pipeline = Pipeline([
+        ('scaler', StandardScaler()),
+        ('model', RandomForestClassifier(random_state=42))
+    ])
+
+    # Train the model
+    pipeline.fit(X_train, y_train)
+
+    # Evaluate the model
+    y_pred = pipeline.predict(X_test)
+    accuracy = accuracy_score(y_test, y_pred)
+    print("Accuracy:", accuracy)
+    print(classification_report(y_test, y_pred))
+
+    # Make predictions on new data
+    # ...
+
+# Main function
+if __name__ == "__main__":
+    # Replace with your GitHub username and repository name
+    username = "miagiii"
+    repository = "miagiii"
+
+    # Fetch issue data from GitHub
+    issues_data = fetch_issue_data(username, repository, 1, 10)  # Fetch issues from pages 1 to 10
+
+    # Clean and structure the data
+    df = clean_and_structure_data(issues_data)
+
+    # Perform exploratory data analysis (EDA)
+    perform_eda(df)
+
+    # Analyze text content using NLP
+    analyze_text_content(df)
+
+    # Create a network graph of issues, authors, and assignees
+    create_network_graph(df)
+
+    # Build a predictive model for issue resolution time
+    build_predictive_model(df)