import streamlit as st from streamlit_ace import st_ace from streamlit_jupyter import st_jupyter from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM import os import subprocess import black from pylint import lint from io import StringIO import sys import torch from huggingface_hub import hf_hub_url, cached_download, HfApi import re from typing import List, Dict # Access Hugging Face API key from secrets hf_token = st.secrets["hf_token"] if not hf_token: st.error("Hugging Face API key not found. Please make sure it is set in the secrets.") HUGGING_FACE_REPO_URL = "https://huggingface.co/spaces/acecalisto3/0shotTest" PROJECT_ROOT = "projects" AGENT_DIRECTORY = "agents" AVAILABLE_CODE_GENERATIVE_MODELS = ["bigcode/starcoder", "Salesforce/codegen-350M-mono", "microsoft/CodeGPT-small"] # 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 = [] # AI Guide Toggle ai_guide_level = st.sidebar.radio("AI Guide Level", ["Full Assistance", "Partial Assistance", "No Assistance"]) class AIAgent: def __init__(self, name: str, description: str, skills: List[str]): self.name = name self.description = description self.skills = skills self._hf_api = HfApi() # Initialize HfApi here def create_agent_prompt(self) -> str: 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: List[tuple[str, str]], workspace_projects: Dict[str, Dict], project_name: str, selected_model: str, hf_token: str) -> tuple[str, str]: 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()]) next_step = "Based on the current state, the next logical step is to implement the main application logic." return summary, next_step def deploy_built_space_to_hf(self, project_name: str) -> str: # Assuming you have a function that generates the space content space_content = generate_space_content(project_name) repository = self._hf_api.create_repo( repo_id=project_name, private=True, token=hf_token, exist_ok=True, space_sdk="streamlit" ) self._hf_api.upload_file( path_or_fileobj=space_content, path_in_repo="app.py", repo_id=project_name, repo_type="space", token=hf_token ) return repository.name def has_valid_hf_token(self) -> bool: return self._hf_api.whoami(token=hf_token) is not None def process_input(input_text: str) -> str: chatbot = pipeline("text-generation", model="microsoft/DialoGPT-medium", tokenizer="microsoft/DialoGPT-medium", clean_up_tokenization_spaces=True) response = chatbot(input_text, max_length=50, num_return_sequences=1)[0]['generated_text'] return response def run_code(code: str) -> str: try: result = subprocess.run(code, shell=True, capture_output=True, text=True) return result.stdout except Exception as e: return str(e) def workspace_interface(project_name: str) -> str: 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." def add_code_to_workspace(project_name: str, code: str, file_name: str) -> str: 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}'." def display_chat_history(chat_history: List[tuple[str, str]]) -> str: return "\n".join([f"User: {u}\nAgent: {a}" for u, a in chat_history]) def display_workspace_projects(workspace_projects: Dict[str, Dict]) -> str: return "\n".join([f"{p}: {details}" for p, details in workspace_projects.items()]) def generate_space_content(project_name: str) -> str: # Logic to generate the Streamlit app content based on project_name # ... (This is where you'll need to implement the actual code generation) return "import streamlit as st\nst.title('My Streamlit App')\nst.write('Hello, world!')" # Function to display the AI Guide chat def display_ai_guide_chat(chat_history: List[tuple[str, str]]): st.markdown("
", unsafe_allow_html=True) for user_message, agent_message in chat_history: st.markdown(f"
{user_message}
", unsafe_allow_html=True) st.markdown(f"
{agent_message}
", unsafe_allow_html=True) st.markdown("
", unsafe_allow_html=True) # Load the CodeGPT tokenizer explicitly code_generator_tokenizer = AutoTokenizer.from_pretrained("microsoft/CodeGPT-small-py", clean_up_tokenization_spaces=True) # Load the CodeGPT model for code completion code_generator = pipeline("text-generation", model="microsoft/CodeGPT-small-py", tokenizer=code_generator_tokenizer) def analyze_code(code: str) -> List[str]: hints = [] # Example pointer: Suggest using list comprehensions if re.search(r'for .* in .*:\n\s+.*\.append\(', code): hints.append("Consider using a list comprehension instead of a loop for appending to a list.") # Example pointer: Recommend using f-strings for string formatting if re.search(r'\".*\%s\"|\'.*\%s\'', code) or re.search(r'\".*\%d\"|\'.*\%d\'', code): hints.append("Consider using f-strings for cleaner and more efficient string formatting.") # Example pointer: Avoid using global variables if re.search(r'\bglobal\b', code): hints.append("Avoid using global variables. Consider passing parameters or using classes.") # Example pointer: Recommend using `with` statement for file operations if re.search(r'open\(.+\)', code) and not re.search(r'with open\(.+\)', code): hints.append("Consider using the `with` statement when opening files to ensure proper resource management.") return hints def get_code_completion(prompt: str) -> str: # Generate code completion based on the current code input # Use max_new_tokens instead of max_length completions = code_generator(prompt, max_new_tokens=50, num_return_sequences=1) return completions[0]['generated_text'] def lint_code(code: str) -> List[str]: # Capture pylint output pylint_output = StringIO() sys.stdout = pylint_output # Run pylint on the provided code pylint.lint.Run(['--from-stdin'], do_exit=False, argv=[], stdin=StringIO(code)) # Reset stdout and fetch lint results sys.stdout = sys.__stdout__ lint_results = pylint_output.getvalue().splitlines() return lint_results # Set page configuration st.set_page_config(layout="wide", page_title="RoboCoders") # Sidebar for chat interface st.sidebar.title("Chat Interface") user_input = st.sidebar.text_area("Type your idea, task, or request here:") # Placeholder function to simulate code generation def generate_code(user_input): return f"# Generated code for: {user_input}\nprint('Hello, World!')" # Main layout col1, col2 = st.columns([1, 3]) with col1: st.title("Code Editor") if user_input: code = generate_code(user_input) else: code = "" code = st_ace(value=code, language='python', theme='monokai', height=400) with col2: st.title("Jupyter IPython Console") st_jupyter() st.title("Read-Only Terminal") st.text_area("Terminal Output", height=200) # Placeholder for autonomous agent logic if user_input: st.sidebar.write("Processing your request...") # Example: Generate a simple "Hello, World!" Streamlit app generated_code = code_generator(f"Create a Streamlit app that displays 'Hello, World!'", max_new_tokens=50, num_return_sequences=1)[0]['generated_text'] st.sidebar.write("Generated code:") st.sidebar.code(generated_code, language="python") # Update the code editor code = generated_code # ... (Additional logic for code analysis, project management, etc.) # ... (Update the Jupyter console and terminal output as needed) # ... (Interact with the AI guide chatbot) if __name__ == "__main__": st.sidebar.title("Navigation") app_mode = st.sidebar.selectbox("Choose the app mode", ["Home", "Terminal", "Explorer", "Code Editor", "Build & Deploy"]) if app_mode == "Home": st.title("Welcome to AI-Guided Development") st.write("This application helps you build and deploy applications with the assistance of an AI Guide.") st.write("Toggle the AI Guide from the sidebar to choose the level of assistance you need.") elif app_mode == "Terminal": st.header("Terminal") terminal_input = st.text_input("Enter a command:") if st.button("Run"): output = run_code(terminal_input) st.session_state.terminal_history.append((terminal_input, output)) st.code(output, language="bash") if ai_guide_level != "No Assistance": st.write("Run commands here to add packages to your project. For example: pip install .") if terminal_input and "install" in terminal_input: package_name = terminal_input.split("install")[-1].strip() st.write(f"Package {package_name} will be added to your project.") elif app_mode == "Explorer": st.header("Explorer") uploaded_file = st.file_uploader("Upload a file", type=["py"]) if uploaded_file: file_details = {"FileName": uploaded_file.name, "FileType": uploaded_file.type} st.write(file_details) save_path = os.path.join(PROJECT_ROOT, uploaded_file.name) with open(save_path, "wb") as f: f.write(uploaded_file.getbuffer()) st.success(f"File {uploaded_file.name} saved successfully!") st.write("Drag and drop files into the 'app' folder.") for project, details in st.session_state.workspace_projects.items(): st.write(f"Project: {project}") for file in details['files']: st.write(f" - {file}") if st.button(f"Move {file} to app folder"): # Logic to move file to 'app' folder pass if ai_guide_level != "No Assistance": st.write("You can upload files and move them into the 'app' folder for building your application.") elif app_mode == "Code Editor": st.header("Code Editor") code_editor = st.text_area("Write your code:", height=300) if st.button("Save Code"): # Logic to save code pass if ai_guide_level != "No Assistance": st.write("The function foo() requires the bar package. Add it to requirements.txt.") # Analyze code and provide real-time hints hints = analyze_code(code_editor) if hints: st.write("**Helpful Hints:**") for hint in hints: st.write(f"- {hint}") if st.button("Get Code Suggestion"): # Provide a predictive code completion completion = get_code_completion(code_editor) st.write("**Suggested Code Completion:**") st.code(completion, language="python") if st.button("Check Code"): # Analyze the code for errors and warnings lint_results = lint_code(code_editor) if lint_results: st.write("**Errors and Warnings:**") for result in lint_results: st.write(result) else: st.write("No issues found! Your code is clean.") elif app_mode == "Build & Deploy": st.header("Build & Deploy") project_name_input = st.text_input("Enter Project Name for Automation:") if st.button("Automate"): selected_agent = st.selectbox("Select an AI agent", st.session_state.available_agents) selected_model = st.selectbox("Select a code-generative model", AVAILABLE_CODE_GENERATIVE_MODELS) 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, project_name_input, selected_model, hf_token) st.write("Autonomous Build Summary:") st.write(summary) st.write("Next Step:") st.write(next_step) if agent._hf_api and agent.has_valid_hf_token(): repository_name = agent.deploy_built_space_to_hf(project_name_input) st.markdown("## Congratulations! Successfully deployed Space 🚀 ##") st.markdown(f"[Check out your new Space here](hf.co/{repository_name})") # AI Guide Chat if ai_guide_level != "No Assistance": display_ai_guide_chat(st.session_state.chat_history) # Add a text input for user to interact with the AI Guide user_input = st.text_input("Ask the AI Guide a question:", key="user_input") if st.button("Send"): if user_input: # Process the user's input and get a response from the AI Guide agent_response = process_input(user_input) st.session_state.chat_history.append((user_input, agent_response)) # Clear the user input field st.session_state.user_input = "" # CSS for styling st.markdown(""" """, unsafe_allow_html=True)