acecalisto3 commited on
Commit
130ded5
·
verified ·
1 Parent(s): 1584745

Update app.py

Browse files
Files changed (1) hide show
  1. app.py +315 -246
app.py CHANGED
@@ -1,248 +1,317 @@
1
- import os
import subprocess
import streamlit as st
from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
import black
from pylint import lint
from io import StringIO
2
- HUGGING_FACE_REPO_URL = "https://huggingface.co/spaces/acecalisto3/DevToolKit"
PROJECT_ROOT = "projects"
AGENT_DIRECTORY = "agents"
3
- Global state to manage communication between Tool Box and Workspace Chat App
4
- 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 = []
if 'current_state' not in st.session_state:
st.session_state.current_state = {
'toolbox': {},
'workspace_chat': {}
}
5
- class AIAgent:
def init(self, name, description, skills):
self.name = name
self.description = description
self.skills = skills
6
-
7
-
8
- def create_agent_prompt(self):
9
- skills_str = '\n'.join([f"* {skill}" for skill in self.skills])
10
- agent_prompt = f"""
11
- As an elite expert developer, my name is {self.name}. I possess a comprehensive understanding of the following areas:
{skills_str}
12
- 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
13
-
14
- def autonomous_build(self, chat_history, workspace_projects):
15
- """
16
- Autonomous build logic that continues based on the state of chat history and workspace projects.
17
- """
18
- summary = "Chat History:\n" + "\n".join([f"User: {u}\nAgent: {a}" for u, a in chat_history])
19
- summary += "\n\nWorkspace Projects:\n" + "\n".join([f"{p}: {details}" for p, details in workspace_projects.items()])
20
-
21
- next_step = "Based on the current state, the next logical step is to implement the main application logic."
22
-
23
- return summary, next_step
24
- def save_agent_to_file(agent):
"""Saves the agent's prompt to a file locally and then commits to the Hugging Face repository."""
if not os.path.exists(AGENT_DIRECTORY):
os.makedirs(AGENT_DIRECTORY)
file_path = os.path.join(AGENT_DIRECTORY, f"{agent.name}.txt")
config_path = os.path.join(AGENT_DIRECTORY, f"{agent.name}Config.txt")
with open(file_path, "w") as file:
file.write(agent.create_agent_prompt())
with open(config_path, "w") as file:
file.write(f"Agent Name: {agent.name}\nDescription: {agent.description}")
st.session_state.available_agents.append(agent.name)
25
-
26
- commit_and_push_changes(f"Add agent {agent.name}")
27
- 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
else:
return None
28
- 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()
29
- Chat interface using a selected agent
30
- 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."
31
-
32
- # Load the GPT-2 model which is compatible with AutoModelForCausalLM
33
- model_name = "gpt2"
34
- try:
35
- model = AutoModelForCausalLM.from_pretrained(model_name)
36
- tokenizer = AutoTokenizer.from_pretrained(model_name)
37
- generator = pipeline("text-generation", model=model, tokenizer=tokenizer)
38
- except EnvironmentError as e:
39
- return f"Error loading model: {e}"
40
-
41
- # Combine the agent prompt with user input
42
- combined_input = f"{agent_prompt}\n\nUser: {input_text}\nAgent:"
43
-
44
- # Truncate input text to avoid exceeding the model's maximum length
45
- max_input_length = 900
46
- input_ids = tokenizer.encode(combined_input, return_tensors="pt")
47
- if input_ids.shape[1] > max_input_length:
48
- input_ids = input_ids[:, :max_input_length]
49
-
50
- # Generate chatbot response
51
- outputs = model.generate(
52
- input_ids, max_new_tokens=50, num_return_sequences=1, do_sample=True, pad_token_id=tokenizer.eos_token_id # Set pad_token_id to eos_token_id
53
- )
54
- response = tokenizer.decode(outputs[0], skip_special_tokens=True)
55
- return response
56
- def workspace_interface(project_name):
project_path = os.path.join(PROJECT_ROOT, project_name)
if not os.path.exists(PROJECT_ROOT):
os.makedirs(PROJECT_ROOT)
if not os.path.exists(project_path):
os.makedirs(project_path)
st.session_state.workspace_projects[project_name] = {"files": []}
st.session_state.current_state['workspace_chat']['project_name'] = project_name
commit_and_push_changes(f"Create project {project_name}")
return f"Project {project_name} created successfully."
else:
return f"Project {project_name} already exists."
57
- def add_code_to_workspace(project_name, code, file_name):
project_path = os.path.join(PROJECT_ROOT, project_name)
if os.path.exists(project_path):
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)
st.session_state.current_state['workspace_chat']['added_code'] = {"file_name": file_name, "code": code}
commit_and_push_changes(f"Add code to {file_name} in project {project_name}")
return f"Code added to {file_name} in project {project_name} successfully."
else:
return f"Project {project_name} does not exist."
58
- def terminal_interface(command, project_name=None):
if project_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."
result = subprocess.run(command, cwd=project_path, shell=True, capture_output=True, text=True)
else:
result = subprocess.run(command, shell=True, capture_output=True, text=True)
if result.returncode == 0:
st.session_state.current_state['toolbox']['terminal_output'] = result.stdout
return result.stdout
else:
st.session_state.current_state['toolbox']['terminal_output'] = result.stderr
return result.stderr
59
- def code_editor_interface(code):
try:
formatted_code = black.format_str(code, mode=black.FileMode())
except black.NothingChanged:
formatted_code = code
result = StringIO()
sys.stdout = result
sys.stderr = result
(pylint_stdout, pylint_stderr) = lint.py_run(code, return_std=True)
sys.stdout = sys.stdout
sys.stderr = sys.stderr
lint_message = pylint_stdout.getvalue() + pylint_stderr.getvalue()
st.session_state.current_state['toolbox']['formatted_code'] = formatted_code
st.session_state.current_state['toolbox']['lint_message'] = lint_message
return formatted_code, lint_message
60
- def summarize_text(text):
summarizer = pipeline("summarization")
summary = summarizer(text, max_length=50, min_length=25, do_sample=False)
st.session_state.current_state['toolbox']['summary'] = summary[0]['summary_text']
return summary[0]['summary_text']
61
- def sentiment_analysis(text):
analyzer = pipeline("sentiment-analysis")
sentiment = analyzer(text)
st.session_state.current_state['toolbox']['sentiment'] = sentiment[0]
return sentiment[0]
62
- def translate_code(code, input_language, output_language):
# Define a dictionary to map programming languages to their corresponding file extensions
language_extensions = {
# ignore the specific languages right now, and continue to EOF
}
63
-
64
- # Add code to handle edge cases such as invalid input and unsupported programming languages
65
- if input_language not in language_extensions:
66
- raise ValueError(f"Invalid input language: {input_language}")
67
- if output_language not in language_extensions:
68
- raise ValueError(f"Invalid output language: {output_language}")
69
-
70
- # Use the dictionary to map the input and output languages to their corresponding file extensions
71
- input_extension = language_extensions[input_language]
72
- output_extension = language_extensions[output_language]
73
-
74
- # Translate the code using the OpenAI API
75
- prompt = f"Translate this code from {input_language} to {output_language}:\n\n{code}"
76
- response = openai.ChatCompletion.create(
77
- model="gpt-4",
78
- messages=[
79
- {"role": "system", "content": "You are an expert software developer."},
80
- {"role": "user", "content": prompt}
81
- ]
82
- )
83
- translated_code = response.choices[0].message['content'].strip()
84
-
85
- # Return the translated code
86
- translated_code = response.choices[0].message['content'].strip()
87
- st.session_state.current_state['toolbox']['translated_code'] = translated_code
88
- return translated_code
89
- def generate_code(code_idea):
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[
{"role": "system", "content": "You are an expert software developer."},
{"role": "user", "content": f"Generate a Python code snippet for the following idea:\n\n{code_idea}"}
]
)
generated_code = response.choices[0].message['content'].strip()
st.session_state.current_state['toolbox']['generated_code'] = generated_code
return generated_code
90
- def commit_and_push_changes(commit_message):
"""Commits and pushes changes to the Hugging Face repository."""
commands = [
"git add .",
f"git commit -m '{commit_message}'",
"git push"
]
for command in commands:
result = subprocess.run(command, shell=True, capture_output=True, text=True)
if result.returncode != 0:
st.error(f"Error executing command '{command}': {result.stderr}")
break
91
- Streamlit App
92
- st.title("AI Agent Creator")
93
- Sidebar navigation
94
- st.sidebar.title("Navigation")
app_mode = st.sidebar.selectbox("Choose the app mode", ["AI Agent Creator", "Tool Box", "Workspace Chat App"])
95
- if app_mode == "AI Agent Creator":
# AI Agent Creator
st.header("Create an AI Agent from Text")
96
-
97
- st.subheader("From Text")
98
- agent_name = st.text_input("Enter agent name:")
99
- text_input = st.text_area("Enter skills (one per line):")
100
- if st.button("Create Agent"):
101
- agent_prompt = create_agent_from_text(agent_name, text_input)
102
- st.success(f"Agent '{agent_name}' created and saved successfully.")
103
- st.session_state.available_agents.append(agent_name)
104
- elif app_mode == "Tool Box":
# Tool Box
st.header("AI-Powered Tools")
105
-
106
- # Chat Interface
107
- st.subheader("Chat with CodeCraft")
108
- chat_input = st.text_area("Enter your message:")
109
- if st.button("Send"):
110
- if chat_input.startswith("@"):
111
- agent_name = chat_input.split(" ")[0][1:] # Extract agent_name from @agent_name
112
- chat_input = " ".join(chat_input.split(" ")[1:]) # Remove agent_name from input
113
- chat_response = chat_interface_with_agent(chat_input, agent_name)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
114
  else:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
115
  chat_response = chat_interface(chat_input)
116
- st.session_state.chat_history.append((chat_input, chat_response))
117
- st.write(f"CodeCraft: {chat_response}")
118
-
119
- # Terminal Interface
120
- st.subheader("Terminal")
121
- terminal_input = st.text_input("Enter a command:")
122
- if st.button("Run"):
123
- terminal_output = terminal_interface(terminal_input)
124
- st.session_state.terminal_history.append((terminal_input, terminal_output))
125
- st.code(terminal_output, language="bash")
126
-
127
- # Code Editor Interface
128
- st.subheader("Code Editor")
129
- code_editor = st.text_area("Write your code:", height=300)
130
- if st.button("Format & Lint"):
131
- formatted_code, lint_message = code_editor_interface(code_editor)
132
- st.code(formatted_code, language="python")
133
- st.info(lint_message)
134
-
135
- # Text Summarization Tool
136
- st.subheader("Summarize Text")
137
- text_to_summarize = st.text_area("Enter text to summarize:")
138
- if st.button("Summarize"):
139
- summary = summarize_text(text_to_summarize)
140
- st.write(f"Summary: {summary}")
141
-
142
- # Sentiment Analysis Tool
143
- st.subheader("Sentiment Analysis")
144
- sentiment_text = st.text_area("Enter text for sentiment analysis:")
145
- if st.button("Analyze Sentiment"):
146
- sentiment = sentiment_analysis(sentiment_text)
147
- st.write(f"Sentiment: {sentiment}")
148
-
149
- # Text Translation Tool (Code Translation)
150
- st.subheader("Translate Code")
151
- code_to_translate = st.text_area("Enter code to translate:")
152
- source_language = st.text_input("Enter source language (e.g. 'Python'):")
153
- target_language = st.text_input("Enter target language (e.g. 'JavaScript'):")
154
- if st.button("Translate Code"):
155
- translated_code = translate_code(code_to_translate, source_language, target_language)
156
- st.code(translated_code, language=target_language.lower())
157
-
158
- # Code Generation
159
- st.subheader("Code Generation")
160
- code_idea = st.text_input("Enter your code idea:")
161
- if st.button("Generate Code"):
162
- generated_code = generate_code(code_idea)
163
- st.code(generated_code, language="python")
164
-
165
- # Display Preset Commands
166
- st.subheader("Preset Commands")
167
- preset_commands = {
168
- "Create a new project": "create_project('project_name')",
169
- "Add code to workspace": "add_code_to_workspace('project_name', 'code', 'file_name')",
170
- "Run terminal command": "terminal_interface('command', 'project_name')",
171
- "Generate code": "generate_code('code_idea')",
172
- "Summarize text": "summarize_text('text')",
173
- "Analyze sentiment": "sentiment_analysis('text')",
174
- "Translate code": "translate_code('code', 'source_language', 'target_language')",
175
- }
176
- for command_name, command in preset_commands.items():
177
- st.write(f"{command_name}: `{command}`")
178
- elif app_mode == "Workspace Chat App":
# Workspace Chat App
st.header("Workspace Chat App")
179
-
180
- # Project Workspace Creation
181
- st.subheader("Create a New Project")
182
- project_name = st.text_input("Enter project name:")
183
- if st.button("Create Project"):
184
- workspace_status = workspace_interface(project_name)
185
- st.success(workspace_status)
186
-
187
- # Add Code to Workspace
188
- st.subheader("Add Code to Workspace")
189
- code_to_add = st.text_area("Enter code to add to workspace:")
190
- file_name = st.text_input("Enter file name (e.g. 'app.py'):")
191
- if st.button("Add Code"):
192
- add_code_status = add_code_to_workspace(project_name, code_to_add, file_name)
193
- st.success(add_code_status)
194
-
195
- # Terminal Interface with Project Context
196
- st.subheader("Terminal (Workspace Context)")
197
- terminal_input = st.text_input("Enter a command within the workspace:")
198
- if st.button("Run Command"):
199
- terminal_output = terminal_interface(terminal_input, project_name)
200
- st.code(terminal_output, language="bash")
201
-
202
- # Chat Interface for Guidance
203
- st.subheader("Chat with CodeCraft for Guidance")
204
- chat_input = st.text_area("Enter your message for guidance:")
205
- if st.button("Get Guidance"):
206
- chat_response = chat_interface(chat_input)
207
- st.session_state.chat_history.append((chat_input, chat_response))
208
- st.write(f"CodeCraft: {chat_response}")
209
-
210
- # Display Chat History
211
- st.subheader("Chat History")
212
- for user_input, response in st.session_state.chat_history:
213
- st.write(f"User: {user_input}")
214
- st.write(f"CodeCraft: {response}")
215
-
216
- # Display Terminal History
217
- st.subheader("Terminal History")
218
- for command, output in st.session_state.terminal_history:
219
- st.write(f"Command: {command}")
220
- st.code(output, language="bash")
221
-
222
- # Display Projects and Files
223
- st.subheader("Workspace Projects")
224
- for project, details in st.session_state.workspace_projects.items():
225
- st.write(f"Project: {project}")
226
- for file in details['files']:
227
- st.write(f" - {file}")
228
-
229
- # Chat with AI Agents
230
- st.subheader("Chat with AI Agents")
231
- selected_agent = st.selectbox("Select an AI agent", st.session_state.available_agents)
232
- agent_chat_input = st.text_area("Enter your message for the agent:")
233
- if st.button("Send to Agent"):
234
- agent_chat_response = chat_interface_with_agent(agent_chat_input, selected_agent)
235
- st.session_state.chat_history.append((agent_chat_input, agent_chat_response))
236
- st.write(f"{selected_agent}: {agent_chat_response}")
237
-
238
- # Automate Build Process
239
- st.subheader("Automate Build Process")
240
- if st.button("Automate"):
241
- agent = AIAgent(selected_agent, "", []) # Load the agent without skills for now
242
- summary, next_step = agent.autonomous_build(st.session_state.chat_history, st.session_state.workspace_projects)
243
- st.write("Autonomous Build Summary:")
244
- st.write(summary)
245
- st.write("Next Step:")
246
- st.write(next_step)
247
- Display current state for debugging
248
- st.sidebar.subheader("Current State")
st.sidebar.json(st.session_state.current_state)
 
1
+ import os
import subprocess
import streamlit as st
from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
import black
from pylint import lint
from io import StringIO
2
+ import = "https://huggingface.co/spaces/acecalisto3/DevToolKit"
PROJECT_ROOT = "projects"
AGENT_DIRECTORY = "agents"os
3
+ import subprocess
4
+ from transformers import pipeline, 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 = []
if 'current_state' not in st.session_state:
st.session_state.current_state = {
'toolbox': {}AutoModelForCausalLM,
'workspace_chat': {}
}AutoTokenizer
5
+ import AIAgent:
def init(self, name, description, skills):
self.name = name
self.description = description
self.skills = skillsblack
6
+ from pylint import lint
7
+ from io import StringIO
8
+ # import openai # We're not using OpenAI anymore
9
+ import sys
10
+
11
+ # Set your Hugging Face API key is {self.name}. I possess a comprehensive understanding of the following areas:
{skills_str}here
12
+ HF_API_KEY = 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.
"YOUR_HUGGING_FACE_API_KEY""
return agent_prompt
13
+
14
+ PROJECT_ROOT = "projects"
15
+ AGENT_DIRECTORY = "agents"
16
+
17
+ # Global state to manage communication between Tool Box and Workspace Chat App
18
+ if 'chat_history' not in st.session_state:
19
+ st.session_state.chat_history = []
20
+ if 'terminal_history' not in st.session_state:
21
+ st.session_state.terminal_history = []
22
+ if 'workspace_projects' not in st.session_state:
23
+ st.session_state.workspace_projects = {}
24
+ if save_agent_to_file(agent):
"""Saves the agent'available_agents' prompt to a file locally and then commits to the Hugging Face repository."""
if not os.path.exists(AGENT_DIRECTORY):
os.makedirs(AGENT_DIRECTORY)
file_pathin = os.path.join(AGENT_DIRECTORY, f"{agent.name}.txt")
config_path = os.path.join(AGENT_DIRECTORY, f"{agent.name}Config.txt")
with open(file_path, "w") as file:
file.write(agent.create_agent_prompt())
with open(config_path, "w") as file:
file.write(f"Agent Name: {agent.name}\nDescription: {agent.description}")
st.session_state:
25
+ st.session_state.available_agents = []
26
+
27
+ class AIAgent:
"""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
else:
return None
28
+ def __init__(self, text):
skills = text.split('\n')
agent = AIAgent(name, description, skills)
save_agent_to_file(agent)
return agent.create_agent_prompt():
29
+ self.name = name
30
+ self.description 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."description
31
+ self.skills = skills
32
+
33
+ def create_agent_prompt(self):
34
+ skills_str = '\n'.join([f"* {skill}" for skill in self.skills])
35
+ agent_prompt = f"""
36
+ As an elite expert developer, my name is {self.name}. I possess a comprehensive understanding of the following areas:
37
+ {skills_str}
38
+
39
+ 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.
40
+ """
41
+ return agent_prompt
42
+
43
+ def autonomous_build(self, chat_history, workspace_projects):
44
+ """
45
+ Autonomous build logic that continues based on the state of chat history and workspace projects.
46
+ """
47
+ # Example logic: Generate a summary of chat history and workspace state
48
+ summary = "Chat History:\n" + "\n".join([f"User: {u}\nAgent: {a}" for u, a in chat_history])
49
+ summary += "\n\nWorkspace Projects:\n" + "\n".join([f"{p}: {details}" for p, details in workspace_projects.items()])
50
+
51
+ # Example: Generate the next logical step in the project
52
+ next_step = "Based on the current state, the next logical step is to implement the main application logic."
53
+
54
+ return summary, next_step
55
+
56
+ def save_agent_to_file(agent):
project_path = os.path.join(PROJECT_ROOT, project_name)
if not os.path.exists(PROJECT_ROOT):
os.makedirs(PROJECT_ROOT)
if not os.path.exists(project_path):
os.makedirs(project_path)
st.session_state.workspace_projects[project_name] = {"files": []}
st.session_state.current_state['workspace_chat']['project_name'] = project_name
commit_and_push_changes(f"Create project {project_name}")
return f"Project {project_name} created successfully."
else:
return f"Project {project_name} already exists."
57
+ def add_code_to_workspace(project_name, code, file_name):
project_path = os.path.join(PROJECT_ROOT, project_name)
if os.path.exists(project_path):
file_path = os.path.join(project_path, file_name)
with open(file_path, """Saves the file:
file.write(code)
st.session_state.workspace_projects[project_name]["files"].append(file_name)
st.session_state.current_state[agent's prompt {"file_name": file_name, "code": code}
commit_and_push_changes(f"Add code to a in project {project_name}")
return f"Code added to {file_name} in project {project_name} successfullyfile."
else:
return f""
58
+ def terminal_interface(command, project_name=None):
 if project_name:
project_path = os.path.join(PROJECT_ROOT, project_name)
if not os.path.exists(AGENT_DIRECTORY):
return f"Project {project_name} does not exist."
result = subprocess.run(command, cwd=project_path, shell=True, capture_output=True, text=True)
else:
result = subprocess.run(command, shell=True, capture_output=True, text=True)
if result.returncode == 0:
st.session_state.current_state['toolbox']['terminal_output'] = result.stdout
return result.stdout
else:
st.session_state.current_state['toolbox']['terminal_output'] = result.stderr
return result.stderr
59
+ def code_editor_interface(code):
try:
formatted_code = black os.makedirs(AGENT_DIRECTORY))
except black.NothingChanged:
formatted_code = code
result = StringIO()
sys.stdout = result
sys.stderr = result
(pylint_stdout, pylint_stderr) = lint.py_run(code, return_std=True)
sys.stdout = sys.stdout
sys.stderr = sys.stderr
lint_message = pylint_stdout.getvalue() + pylint_stderr.getvalue()
st.session_state.current_state['toolbox']['formatted_code'] = formatted_code
st.session_state.current_state['toolbox']['lint_message'] = lint_message
return formatted_code, lint_message
60
+ file_path summarize_text(text):
summarizer = os.path.join("summarization")
summary = summarizer(textAGENT_DIRECTORY, max_length=50, min_length=25, do_sample=False)
stf"{agent.name}.current_state['toolbox']['summary'] = summary[0]['summary_text']
return summary[0]['summary_text']txt")
61
+ with open(text):
analyzerfile_path, "w")
sentiment as analyzer(text)
st.session_state.current_state['toolbox']['sentiment'] = sentiment[0]
return sentiment[0]file:
62
+ file.write(agent.create_agent_prompt():
# Define a dictionary to map programming languages to their corresponding file extensions
language_extensions = {
# ignore the specific languages right now, and continue to EOF
})
63
+ st.session_state.available_agents.append(agent.name)
64
+
65
+ def load_agent_prompt(agent_name):
66
+ """Loads an agent prompt from a file."""
67
+ file_path = os.path.join(AGENT_DIRECTORY, f"{agent_name}.txt")
68
+ if os.path.exists(file_path):
69
+ with open(file_path, "r") as file:
70
+ agent_prompt = file.read()
71
+ return agent_prompt
72
+ else:
73
+ return None
74
+
75
+ def create_agent_from_text(name, text):
76
+ skills = text.split('\n')
77
+ agent = AIAgent(name, "AI agent created from text input.", skills)
78
+ save_agent_to_file(agent)
79
+ return agent.create_agent_prompt()
80
+
81
+ # Chat interface using a selected agent (Hugging Face version)
82
+ def chat_interface_with_agent(input_text, agent_name):
83
+ agent_prompt = load_agent_prompt(agent_name)
84
+ if agent_prompt is None:
85
+ return f"Agent {agent_name} not found."
86
+
87
+ # Use a Hugging Face model for chat with the agent
88
+ # Example: Using the 'google/flan-t5-xl' model
89
+ generator generate_code(code_idea):
response = pipeline(
model="text-generation",
messages model=[
{"google/flan-t5-xl", "content": "You are an expert software developer."},
{"role": "user", "content": f"Generate a Python code snippet for the following idea:\n\n{code_idea}"}
]
)
generated_code use_auth_token=HF_API_KEY)
st.session_state.current_state['toolbox']['generated_code'] = generated_code
return generated_code
90
+ def commit_and_push_changes(commit_message):
"""Commits and pushes changes to the Hugging Face repository."""
commands = [
"git add .",
f"git commit -m '{commit_message}'",
"git push"
]
for command in commands:
result = subprocess.run(command, shell=True, capture_output=True, text=True)
if result.returncode != 0:
st.error(f"Error executing command '{command}': {result.stderr}")
break
91
+ # Combine the agent prompt with user input
92
+ combined_input = f"{agent_prompt}\n\nUser: {input_text}\nAgent:"
93
+
94
+ st.sidebar.title("Navigation")
app_mode # Generate chatbot response
95
+ response = == "AI Agent Creator":
# AI Agent Creator
st.headergenerator(combined_input, max_length=150, num_return_sequences=1, do_sample=True)
96
+ return response[0]['generated_text']
97
+
98
+ # Terminal interface
99
+ def terminal_interface(command, project_name=None):
100
+ if project_name:
101
+ project_path = os.path.join(PROJECT_ROOT, project_name)
102
+ result = subprocess.run(command, shell=True, capture_output=True, text=True, cwd=project_path)
103
+ else:
104
+ result = subprocess.run(command, shell=True, Box":
#capture_output=True, Tool Box
st.header("AI-Powered Tools"text=True)
105
+ return result.stdout
106
+
107
+ # Code editor interface
108
+ def code_editor_interface(code):
109
+ formatted_code = black.format_str(code, mode=black.FileMode())
110
+ pylint_output = lint.Run([formatted_code], do_exit=False)
111
+ pylint_output_str = StringIO()
112
+ pylint_output.linter.reporter.write_messages(pylint_output_str)
113
+ return formatted_code, pylint_output_str.getvalue()
114
+
115
+ # Text summarization tool
116
+ def summarize_text(text):
117
+ summarizer = pipeline("summarization", model="facebook/bart-large-cnn", use_auth_token=HF_API_KEY)
118
+ summary = summarizer(text, max_length=130, min_length=30, do_sample=False)
119
+ return summary[0]['summary_text']
120
+
121
+ # Sentiment analysis tool
122
+ def sentiment_analysis(text):
123
+ analyzer = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-3-literal", use_auth_token=HF_API_KEY)
124
+ result = analyzer(text)
125
+ return result[0]['label']
126
+
127
+ # Text translation tool (code translation)
128
+ def translate_code(code, source_language, target_language):
129
+ # Placeholder for translation logic
130
+ return f"Translated {source_language} code to {target_language}."
131
+
132
+ # Code generation tool
133
+ def generate_code(idea):
134
+ # Use a Hugging Face model for code generation
135
+ # Example: Using the 'Salesforce/codet5-base' model
136
+ generator = pipeline("text-generation", model="Salesforce/codet5-base", use_auth_token=HF_API_KEY)
137
+ response = generator(idea, max_length=150, num_return_sequences=1, do_sample=True)
138
+ return response[0]['generated_text']
139
+
140
+ # Workspace interface
141
+ def workspace_interface(project_name):
142
+ project_path = os.path.join(PROJECT_ROOT, project_name)
143
+ if not os.path.exists(project_path):
144
+ os.makedirs(project_path)
145
+ st.session_state.workspace_projects[project_name] = {'files': []}
146
+ return f"Project '{project_name}' created successfully."
147
  else:
148
+ return f"Project '{project_name}' already exists."
149
+
150
+ # Add code to workspace
151
+ def add_code_to_workspace(project_name, code, file_name):
152
+ project_path = os.path.join(PROJECT_ROOT, project_name)
153
+ if not os.path.exists(project_path):
154
+ return f"Project '{project_name}' does not exist."
155
+
156
+ file_path = os.path.join(project_path, file_name)
157
+ with open(file_path, "w") as file:
158
+ file.write(code)
159
+ st.session_state.workspace_projects[project_name]['files'].append(file_name)
160
+ return f"Code added to '{file_name}' in project '{project_name}'."
161
+
162
+ # Chat interface (Hugging Face version)
163
+ def chat_interface(input_text):
164
+ # Use a Hugging Face model for chat
165
+ # Example: Using the 'google/flan-t5-xl' model
166
+ generator = pipeline("text-generation", model="google/flan-t5-xl", use_auth_token=HF_API_KEY)
167
+ response = generator(input_text, max_length=150, num_return_sequences=1, do_sample=True)
168
+ return response[0]['generated_text']
169
+
170
+ # Streamlit App
171
+ st.title("AI Agent Creator")
172
+
173
+ # Sidebar navigation
174
+ st.sidebar.title("Navigation")
175
+ app_mode = st.sidebar.selectbox("Choose the app mode", ["AI Agent Creator", "Tool Box", "Workspace Chat App"])
176
+
177
+ if app_mode == "AI Agent Creator":
178
+ # AI Agent Creator
179
+ st.header("Create an AI Agent from Text")
180
+
181
+ st.subheader("From Text")
182
+ agent_name = st.text_input("Enter agent name:")
183
+ text_input = st.text_area("Enter skills (one per line):")
184
+ if st.button("Create Agent"):
185
+ agent_prompt = create_agent_from_text(agent_name, text_input)
186
+ st.success(f"Agent '{agent_name}' created and saved successfully.")
187
+ st.session_state.available_agents.append(agent_name)
188
+
189
+ elif app_mode == "Tool Box":
190
+ # Tool Box
191
+ st.header("AI-Powered Tools")
192
+
193
+ # Chat Interface
194
+ st.subheader("Chat with CodeCraft")
195
+ chat_input = st.text_area("Enter your message:")
196
+ if st.button("Send"):
197
+ chat_response = chat_interface(chat_input)
198
+ st.session_state.chat_history.append((chat_input, chat_response))
199
+ st.write(f"CodeCraft: {chat_response}")
200
+
201
+ # Terminal Interface
202
+ st.subheader("Terminal")
203
+ terminal_input = st.text_input("Enter a command:")
204
+ if st.button("Run"):
205
+ terminal_output = terminal_interface(terminal_input)
206
+ st.session_state.terminal_history.append((terminal_input, terminal_output))
207
+ st.code(terminal_output, language="bash")
208
+
209
+ # Code Editor Interface
210
+ st.subheader("Code Editor")
211
+ code_editor = st.text_area("Write your code:", height=300)
212
+ if st.button("Format & Lint"):
213
+ formatted_code, lint_message = code_editor_interface(code_editor)
214
+ st.code(formatted_code, language="python")
215
+ st.info(lint_message)
216
+
217
+ # Text Summarization Tool
218
+ st.subheader("Summarize Text")
219
+ text_to_summarize = st.text_area("Enter text to summarize:")
220
+ if st.button("Summarize"):
221
+ summary = summarize_text(text_to_summarize)
222
+ st.write(f"Summary: {summary}")
223
+
224
+ # Sentiment Analysis Tool
225
+ st.subheader("Sentiment Analysis")
226
+ sentiment_text = st.text_area("Enter text for sentiment analysis:")
227
+ if st.button("Analyze Sentiment"):
228
+ sentiment = sentiment_analysis(sentiment_text)
229
+ st.write(f"Sentiment: {sentiment}")
230
+
231
+ # Text Translation Tool (Code Translation)
232
+ st.subheader("Translate Code")
233
+ code_to_translate = st.text_area("Enter code to translate:")
234
+ source_language = st.text_input("Enter source language (e.g., 'Python'):")
235
+ target_language = st.text_input("Enter target language (e.g., 'JavaScript'):")
236
+ if st.button("Translate Code"):
237
+ translated_code = translate_code(code_to_translate, source_language, target_language)
238
+ st.code(translated_code, language=target_language.lower())
239
+
240
+ # Code Generation
241
+ st.subheader("Code Generation")
242
+ code_idea = st.text_input("Enter your code idea:")
243
+ if st.button("Generate Code"):
244
+ generated_code = generate_code(code_idea)
245
+ st.code(generated_code, language="python")
246
+
247
+ elif app_mode == "Workspace Chat App":
248
+ # Workspace Chat App
249
+ st.header("Workspace Chat App")
250
+
251
+ # Project Workspace Creation
252
+ st.subheader("Create a New Project")
253
+ project_name = st.text_input("Enter project name:")
254
+ if st.button("Create Project"):
255
+ workspace_status = workspace_interface(project_name)
256
+ st.success(workspace_status)
257
+
258
+ # Add Code to Workspace
259
+ st.subheader("Add Code to Workspace")
260
+ code_to_add = st.text_area("Enter code to add to workspace:")
261
+ file_name = st.text_input("Enter file name (e.g., 'app.py'):")
262
+ if st.button("Add Code"):
263
+ add_code_status = add_code_to_workspace(project_name, code_to_add, file_name)
264
+ st.success(add_code_status)
265
+
266
+ # Terminal Interface with Project Context
267
+ st.subheader("Terminal (Workspace Context)")
268
+ terminal_input = st.text_input("Enter a command within the workspace:")
269
+ if st.button("Run Command"):
270
+ terminal_output = terminal_interface(terminal_input, project_name)
271
+ st.code(terminal_output, language="bash")
272
+
273
+ # Chat Interface for Guidance
274
+ st.subheader("Chat with CodeCraft for Guidance")
275
+ chat_input = st.text_area("Enter your message for guidance:")
276
+ if st.button("Get Guidance"):
277
  chat_response = chat_interface(chat_input)
278
+ st.session_state.chat_history.append((chat_input, chat_response))
279
+ st.write(f"CodeCraft: {chat_response}")
280
+
281
+ # Display Chat History
282
+ st.subheader("Chat History")
283
+ for user_input, response in st.session_state.chat_history:
284
+ st.write(f"User: {user_input}")
285
+ st.write(f"CodeCraft: {response}")
286
+
287
+ # Display Terminal History
288
+ st.subheader("Terminal History")
289
+ for command, output in st.session_state.terminal_history:
290
+ st.write(f"Command: {command}")
291
+ st.code(output, language="bash")
292
+
293
+ # Display Projects and Files
294
+ st.subheader("Workspace Projects")
295
+ for project, details in st.session_state.workspace_projects.items():
296
+ st.write(f"Project: {project}")
297
+ for file in details['files']:
298
+ st.write(f" - {file}")
299
+
300
+ # Chat with AI Agents
301
+ st.subheader("Chat with AI Agents")
302
+ selected_agent = st.selectbox("Select an AI agent", st.session_state.available_agents)
303
+ agent_chat_input = st.text_area("Enter your message for the agent:")
304
+ if st.button("Send to Agent"):
305
+ agent_chat_response = chat_interface_with_agent(agent_chat_input, selected_agent)
306
+ st.session_state.chat_history.append((agent_chat_input, agent_chat_response))
307
+ st.write(f"{selected_agent}: {agent_chat_response}")
308
+
309
+ # Automate Build Process
310
+ st.subheader("Automate Build Process")
311
+ if st.button("Automate"):
312
+ agent = AIAgent(selected_agent, "", []) # Load the agent without skills for now
313
+ summary, next_step = agent.autonomous_build(st.session_state.chat_history, st.session_state.workspace_projects)
314
+ st.write("Autonomous Build Summary:")
315
+ st.write(summary)
316
+ st.write("Next Step:")
317
+ st.write(next_step)