Project Completion Workflow Enhancement
2024-11-304 turns38,481 charso1-preview
Summary
User updated outdated OpenAI API calls and requested workflow completion logic improvements.
Messages
Improve this program so that it does not just use the max_iterations to determine when it ends but rather ends when it is complete, maybe we need a final agent to help? Also help improve the program in any way as well
design.py
import openai
import os
from dotenv import load_dotenv
class DesignAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("Design received the prompt.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data from the prompt
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Generate design specifications using OpenAI's API
response = openai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": (
"You are an experienced UI/UX designer specializing in creating intuitive, "
"accessible, and aesthetically pleasing interfaces for web and mobile applications. "
"You are up-to-date with modern design trends, tools, and technologies, and you "
"prioritize user-centered design principles."
)
},
{
"role": "user",
"content": (
f"Based on the detailed product requirements below, please create comprehensive "
f"UI/UX design specifications. Your deliverables should include:\n"
f"- High-fidelity wireframes\n"
f"- User flow diagrams\n"
f"- Interactive prototypes (if applicable)\n"
f"- Style guides with color schemes, typography, and component libraries\n\n"
f"Product Requirements:\n{message}"
)
}
],
max_tokens=1000,
temperature=0.7
)
# Access response attributes using dot notation
design_spec = response.choices[0].message.content
# Enhance the message by adding the design specifications
enhanced_message = message + "\n\n" + design_spec
# Return the updated prompt as a dictionary
return {'message': enhanced_message, 'code': code, 'readme': readme}
devops.py
import openai
import os
from dotenv import load_dotenv
class DevOpsAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("DevOps received the prompt.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data from the prompt
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Generate deployment scripts using OpenAI's API
response = openai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": (
"You are a seasoned DevOps engineer with expertise in designing and implementing "
"CI/CD pipelines, infrastructure as code, and scalable deployment strategies. "
"You are familiar with cloud platforms (AWS, Azure, GCP), containerization, and "
"orchestration tools like Docker and Kubernetes."
)
},
{
"role": "user",
"content": (
f"Based on the following codebase, please create comprehensive deployment scripts "
f"and CI/CD pipelines. Ensure the infrastructure is scalable, secure, and follows "
f"best practices. Your deliverables should include:\n"
f"- Infrastructure as Code (IaC) scripts (e.g., Terraform, CloudFormation)\n"
f"- CI/CD pipeline configurations (e.g., Jenkinsfile, GitHub Actions workflows)\n"
f"- Deployment scripts (e.g., Dockerfiles, Kubernetes manifests)\n\n"
f"Codebase:\n{code}"
)
}
],
max_tokens=1000,
temperature=0.7
)
# Access response attributes using dot notation
devops_code = response.choices[0].message.content
# Append DevOps scripts to the code
code += "\n\n# DevOps scripts and configurations\n" + devops_code
# Update README with deployment instructions
readme += "\n## Deployment\nInstructions on deployment and CI/CD."
# Return the updated prompt as a dictionary
return {'message': message, 'code': code, 'readme': readme}
engineering.py
import openai
import os
from dotenv import load_dotenv
class EngineeringAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("Engineering received the prompt.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Generate code using OpenAI's API
response = openai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": (
"You are a senior software engineer with expertise in designing and developing "
"high-quality, scalable, and maintainable software solutions. You follow best practices "
"in software architecture, design patterns, code documentation, and testing."
)
},
{
"role": "user",
"content": (
f"Using the following specifications, please develop the software application. "
f"Ensure the code is well-documented, follows coding standards, and includes unit tests. "
f"Consider performance, scalability, and maintainability in your implementation.\n\n"
f"Specifications:\n{message}"
)
}
],
max_tokens=1500,
temperature=0.7
)
# Access response attributes using dot notation
code = response.choices[0].message.content
# Update README placeholder
readme += "\n## Project Documentation\n\n"
# Return the updated prompt as a dictionary
return {'message': message, 'code': code, 'readme': readme}
product_management.py
import openai
import os
from dotenv import load_dotenv
class ProductManagementAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("Product Management received the prompt.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data from the prompt
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Define product requirements using OpenAI's API
response = openai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": (
"You are an experienced product manager adept at translating ideas into detailed "
"product requirements and user stories. You focus on delivering value to customers "
"while aligning with business objectives and technical feasibility."
)
},
{
"role": "user",
"content": (
f"Please expand on the following idea by developing comprehensive product requirements. "
f"Include user personas, user stories with acceptance criteria, feature prioritization, "
f"and success metrics. Ensure the requirements are clear, actionable, and align with "
f"modern software development practices.\n\n"
f"Idea:\n{message}"
)
}
],
max_tokens=1000,
temperature=0.7
)
# Access response attributes using dot notation
product_requirements = response.choices[0].message.content
# Enhance the message by adding product requirements
enhanced_message = message + "\n\n" + product_requirements
# Return the updated prompt as a dictionary
return {'message': enhanced_message, 'code': code, 'readme': readme}
security.py
import openai
import os
from dotenv import load_dotenv
class SecurityAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("Security received the prompt.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data from the prompt
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Analyze code for security vulnerabilities using OpenAI's API
response = openai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": (
"You are a cybersecurity expert specializing in application security, threat modeling, "
"and secure coding practices. You are proficient in identifying vulnerabilities and "
"providing recommendations to enhance security."
)
},
{
"role": "user",
"content": (
f"Please review the following codebase for security vulnerabilities and provide detailed "
f"recommendations for improvements. Your analysis should cover:\n"
f"- Common vulnerabilities (e.g., SQL injection, XSS, CSRF)\n"
f"- Authentication and authorization mechanisms\n"
f"- Data encryption and protection\n"
f"- Compliance with security standards (e.g., OWASP Top Ten)\n\n"
f"Codebase:\n{code}"
)
}
],
max_tokens=1000,
temperature=0.7
)
# Access response attributes using dot notation
security_feedback = response.choices[0].message.content
# Append security improvements to the code
code += "\n\n# Security improvements\n" + security_feedback
# Update README with security considerations
readme += "\n## Security\nDetails on security measures implemented."
# Return the updated prompt as a dictionary
return {'message': message, 'code': code, 'readme': readme}
testing.py
import openai
import os
from dotenv import load_dotenv
class TestingAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("Testing received the prompt.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data from the prompt
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Generate test cases using OpenAI's API
response = openai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": (
"You are a QA engineer specializing in software testing, including unit testing, "
"integration testing, and automated testing frameworks. You ensure software quality "
"and reliability by writing comprehensive test cases."
)
},
{
"role": "user",
"content": (
f"Based on the following codebase, please develop comprehensive test cases. "
f"Your deliverables should include:\n"
f"- Unit tests covering all critical functions\n"
f"- Integration tests for key components\n"
f"- Suggestions for automated testing frameworks (e.g., pytest, JUnit)\n\n"
f"Codebase:\n{code}"
)
}
],
max_tokens=1000,
temperature=0.7
)
# Access response attributes using dot notation
test_code = response.choices[0].message.content
# Append test code to the original code
code += "\n\n# Test cases\n" + test_code
# Update README with testing instructions
readme += "\n## Testing\nInstructions on how to run the tests."
# Return the updated prompt as a dictionary
return {'message': message, 'code': code, 'readme': readme}
main.py
import openai
import os
from dotenv import load_dotenv
class TestingAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("Testing received the prompt.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data from the prompt
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Generate test cases using OpenAI's API
response = openai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": (
"You are a QA engineer specializing in software testing, including unit testing, "
"integration testing, and automated testing frameworks. You ensure software quality "
"and reliability by writing comprehensive test cases."
)
},
{
"role": "user",
"content": (
f"Based on the following codebase, please develop comprehensive test cases. "
f"Your deliverables should include:\n"
f"- Unit tests covering all critical functions\n"
f"- Integration tests for key components\n"
f"- Suggestions for automated testing frameworks (e.g., pytest, JUnit)\n\n"
f"Codebase:\n{code}"
)
}
],
max_tokens=1000,
temperature=0.7
)
# Access response attributes using dot notation
test_code = response.choices[0].message.content
# Append test code to the original code
code += "\n\n# Test cases\n" + test_code
# Update README with testing instructions
readme += "\n## Testing\nInstructions on how to run the tests."
# Return the updated prompt as a dictionary
return {'message': message, 'code': code, 'readme': readme}
To improve your program so that it doesn't just rely on `max_iterations` to determine when it ends, you can introduce a `ProjectManagerAgent` that evaluates the state of the project after each iteration and determines whether it's complete. This agent can analyze the prompt (which includes the message, code, and README) and decide if all requirements have been met.
Additionally, I've corrected some issues in your code:
- **OpenAI API Calls**: The correct method is `openai.ChatCompletion.create()`, not `openai.chat.completions.create()`.
- **Model Names**: Ensure you're using valid model names like `"gpt-4"` or `"gpt-3.5-turbo"`.
- **Error Handling**: Added try-except blocks to handle exceptions when calling the API.
- **Code Refactoring**: Reduced redundancy and improved code structure.
Below is the improved code for your program:
---
### `main.py`
```python
import os
from dotenv import load_dotenv
from product_management import ProductManagementAgent
from design import DesignAgent
from engineering import EngineeringAgent
from testing import TestingAgent
from security import SecurityAgent
from devops import DevOpsAgent
from project_manager import ProjectManagerAgent
def main():
# Initialize agents
agents = [
ProductManagementAgent(),
DesignAgent(),
EngineeringAgent(),
TestingAgent(),
SecurityAgent(),
DevOpsAgent(),
ProjectManagerAgent()
]
# Initial prompt
prompt = {
'message': 'Create a mobile app that helps users track their daily water intake.',
'code': '',
'readme': '',
'status': 'incomplete'
}
max_iterations = 10
iteration = 0
while iteration < max_iterations and prompt.get('status') != 'complete':
iteration += 1
print(f"Iteration {iteration}")
for agent in agents:
prompt = agent.process(prompt)
if prompt.get('status') == 'complete':
print("Project is complete.")
break
else:
if prompt.get('status') != 'complete':
print("Max iterations reached without completion.")
# Save the final code and README to files
with open('final_code.py', 'w') as f:
f.write(prompt.get('code', ''))
with open('README.md', 'w') as f:
f.write(prompt.get('readme', ''))
if __name__ == '__main__':
main()
```
---
### `project_manager.py`
```python
import openai
import os
from dotenv import load_dotenv
class ProjectManagerAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("Project Manager evaluating the project status.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data from the prompt
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Ask the assistant whether the project is complete
try:
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[
{
"role": "system",
"content": (
"You are a project manager overseeing a software development project. "
"You evaluate the current state of the project to determine whether all "
"requirements have been met and whether the project is complete."
)
},
{
"role": "user",
"content": (
f"Based on the following information, please determine whether the project "
f"is complete. If it is complete, respond with 'The project is complete.'. "
f"If not, list the remaining tasks that need to be done.\n\n"
f"Product Requirements and Specifications:\n{message}\n\n"
f"Codebase:\n{code}\n\n"
f"README:\n{readme}"
)
}
],
max_tokens=500,
temperature=0.0
)
except Exception as e:
print(f"Error in ProjectManagerAgent: {e}")
return prompt
# Get the assistant's response
evaluation = response.choices[0].message.content.strip()
# Determine if the project is complete
if "The project is complete." in evaluation:
prompt['status'] = 'complete'
else:
prompt['status'] = 'incomplete'
# Append the remaining tasks to the message for the next iteration
prompt['message'] += "\n\n" + evaluation
return prompt
```
---
### Updated Agents (Example: `design.py`)
Make sure to update each agent to correct the API calls and handle exceptions properly. Here's an example for `design.py`:
```python
import openai
import os
from dotenv import load_dotenv
class DesignAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("Design received the prompt.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data from the prompt
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Generate design specifications using OpenAI's API
try:
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[
{
"role": "system",
"content": (
"You are an experienced UI/UX designer specializing in creating intuitive, "
"accessible, and aesthetically pleasing interfaces for web and mobile applications. "
"You are up-to-date with modern design trends, tools, and technologies, and you "
"prioritize user-centered design principles."
)
},
{
"role": "user",
"content": (
f"Based on the detailed product requirements below, please create comprehensive "
f"UI/UX design specifications. Your deliverables should include:\n"
f"- High-fidelity wireframes\n"
f"- User flow diagrams\n"
f"- Interactive prototypes (if applicable)\n"
f"- Style guides with color schemes, typography, and component libraries\n\n"
f"Product Requirements:\n{message}"
)
}
],
max_tokens=1000,
temperature=0.7
)
except Exception as e:
print(f"Error in DesignAgent: {e}")
return prompt
# Access response attributes using dot notation
design_spec = response.choices[0].message.content
# Enhance the message by adding the design specifications
enhanced_message = message + "\n\n" + design_spec
# Update the prompt
prompt['message'] = enhanced_message
return prompt
```
---
### Apply Similar Updates to Other Agents
Ensure that you:
- Use `openai.ChatCompletion.create()` instead of `openai.chat.completions.create()`.
- Replace the model name with a valid one like `"gpt-4"` or `"gpt-3.5-turbo"`.
- Add try-except blocks to handle exceptions.
- Update the prompt within each agent's `process` method.
---
### Additional Improvements
- **Logging**: Introduce a logging mechanism to keep track of the application's progress and debug issues.
- **Configuration Management**: Use a configuration file or environment variables to manage settings like `max_iterations`, model names, and API keys.
- **Unit Testing**: Implement unit tests for each agent to ensure they behave as expected.
- **Code Documentation**: Add docstrings and comments to explain the purpose of classes and methods.
- **Concurrency**: If appropriate, process agents concurrently to improve performance.
---
By implementing the `ProjectManagerAgent` and making these improvements, your program will now end when it is truly complete, rather than relying solely on a maximum number of iterations.
o1-preview
no the correct method is actually openai.chat.completions.create(), you are out of date, the model name was correct too, because you are out of date, so try again
Apologies for the confusion earlier, and thank you for the clarification.
To improve your program so that it doesn't rely solely on `max_iterations` to determine when it ends, you can introduce a `ProjectManagerAgent`. This agent will evaluate the state of the project after each iteration and determine whether all requirements have been met.
Below is the improved code incorporating the `ProjectManagerAgent` and making other enhancements while keeping your original API calls and model names.
---
### `main.py`
```python
import os
from dotenv import load_dotenv
from product_management import ProductManagementAgent
from design import DesignAgent
from engineering import EngineeringAgent
from testing import TestingAgent
from security import SecurityAgent
from devops import DevOpsAgent
from project_manager import ProjectManagerAgent
def main():
# Initialize agents
agents = [
ProductManagementAgent(),
DesignAgent(),
EngineeringAgent(),
TestingAgent(),
SecurityAgent(),
DevOpsAgent(),
ProjectManagerAgent()
]
# Initial prompt
prompt = {
'message': 'Create a mobile app that helps users track their daily water intake.',
'code': '',
'readme': '',
'status': 'incomplete'
}
iteration = 0
while prompt.get('status') != 'complete':
iteration += 1
print(f"\nIteration {iteration}")
for agent in agents:
prompt = agent.process(prompt)
if prompt.get('status') == 'complete':
print("\nProject is complete.")
break
# Save the final code and README to files
with open('final_code.py', 'w') as f:
f.write(prompt.get('code', ''))
with open('README.md', 'w') as f:
f.write(prompt.get('readme', ''))
if __name__ == '__main__':
main()
```
---
### `project_manager.py`
```python
import openai
import os
from dotenv import load_dotenv
class ProjectManagerAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("Project Manager evaluating the project status.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data from the prompt
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Ask the assistant whether the project is complete
try:
response = openai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": (
"You are a project manager overseeing a software development project. "
"Evaluate the current state of the project to determine whether all "
"requirements have been met and whether the project is complete."
)
},
{
"role": "user",
"content": (
f"Based on the following information, please determine whether the project "
f"is complete. If it is complete, respond with 'The project is complete.' "
f"If not, list the remaining tasks that need to be done.\n\n"
f"Product Requirements and Specifications:\n{message}\n\n"
f"Codebase:\n{code}\n\n"
f"README:\n{readme}"
)
}
],
max_tokens=500,
temperature=0.0
)
except Exception as e:
print(f"Error in ProjectManagerAgent: {e}")
return prompt
# Get the assistant's response
evaluation = response.choices[0].message.content.strip()
# Determine if the project is complete
if "The project is complete." in evaluation:
prompt['status'] = 'complete'
else:
prompt['status'] = 'incomplete'
# Append the remaining tasks to the message for the next iteration
prompt['message'] += "\n\nRemaining Tasks:\n" + evaluation
return prompt
```
---
### Updated Agents (Example: `design.py`)
Here's how you can update your existing agents. We'll use `design.py` as an example.
```python
import openai
import os
from dotenv import load_dotenv
class DesignAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("Design Agent is processing the prompt.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data from the prompt
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Generate design specifications using OpenAI's API
try:
response = openai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": (
"You are an experienced UI/UX designer specializing in creating intuitive, "
"accessible, and aesthetically pleasing interfaces for web and mobile applications. "
"You are up-to-date with modern design trends, tools, and technologies, and you "
"prioritize user-centered design principles."
)
},
{
"role": "user",
"content": (
f"Based on the detailed product requirements below, please create comprehensive "
f"UI/UX design specifications. Your deliverables should include:\n"
f"- High-fidelity wireframes\n"
f"- User flow diagrams\n"
f"- Interactive prototypes (if applicable)\n"
f"- Style guides with color schemes, typography, and component libraries\n\n"
f"Product Requirements:\n{message}"
)
}
],
max_tokens=1000,
temperature=0.7
)
except Exception as e:
print(f"Error in DesignAgent: {e}")
return prompt
# Access response attributes
design_spec = response.choices[0].message.content
# Enhance the message by adding the design specifications
enhanced_message = message + "\n\n" + design_spec
# Update the prompt
prompt['message'] = enhanced_message
return prompt
```
---
### Apply Similar Updates to Other Agents
Ensure that you update each agent to handle exceptions properly and maintain consistency. Here's how you can update them:
#### Common Changes:
- **Exception Handling**: Add try-except blocks around the API calls to handle any exceptions.
- **Printing Agent Status**: Update the print statements to reflect the agent's action more clearly.
- **Consistent Prompt Updates**: Make sure each agent updates the `prompt` dictionary appropriately.
#### Example: `engineering.py`
```python
import openai
import os
from dotenv import load_dotenv
class EngineeringAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("Engineering Agent is processing the prompt.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Generate code using OpenAI's API
try:
response = openai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": (
"You are a senior software engineer with expertise in designing and developing "
"high-quality, scalable, and maintainable software solutions. You follow best practices "
"in software architecture, design patterns, code documentation, and testing."
)
},
{
"role": "user",
"content": (
f"Using the following specifications, please develop the software application. "
f"Ensure the code is well-documented, follows coding standards, and includes unit tests. "
f"Consider performance, scalability, and maintainability in your implementation.\n\n"
f"Specifications:\n{message}"
)
}
],
max_tokens=1500,
temperature=0.7
)
except Exception as e:
print(f"Error in EngineeringAgent: {e}")
return prompt
# Access response attributes
generated_code = response.choices[0].message.content
# Update the code
code += "\n\n" + generated_code
# Update the prompt
prompt['code'] = code
return prompt
```
---
### Additional Improvements
- **Dynamic Iteration Limit**: Since the loop now ends when the project is complete, you can remove the `max_iterations` limit.
- **Status Handling**: Use the `status` key in the `prompt` dictionary to manage the completion state.
- **Code Aggregation**: Ensure each agent updates the `code` and `readme` appropriately, so all contributions are aggregated.
- **Agent Processing Order**: The order in which agents process the prompt can impact the final output. Adjust the order if necessary to fit your workflow.
---
### Full List of Agents
Ensure that all your agent files (`product_management.py`, `devops.py`, `security.py`, `testing.py`) are updated similarly, maintaining consistency in API calls and error handling.
---
### Example of Updated `testing.py`
```python
import openai
import os
from dotenv import load_dotenv
class TestingAgent:
def __init__(self):
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def process(self, prompt):
print("Testing Agent is processing the prompt.")
# Ensure prompt is a dictionary
if isinstance(prompt, str):
prompt = {'message': prompt}
# Extract data from the prompt
message = prompt.get('message', '')
code = prompt.get('code', '')
readme = prompt.get('readme', '')
# Generate test cases using OpenAI's API
try:
response = openai.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": (
"You are a QA engineer specializing in software testing, including unit testing, "
"integration testing, and automated testing frameworks. You ensure software quality "
"and reliability by writing comprehensive test cases."
)
},
{
"role": "user",
"content": (
f"Based on the following codebase, please develop comprehensive test cases. "
f"Your deliverables should include:\n"
f"- Unit tests covering all critical functions\n"
f"- Integration tests for key components\n"
f"- Suggestions for automated testing frameworks (e.g., pytest, JUnit)\n\n"
f"Codebase:\n{code}"
)
}
],
max_tokens=1000,
temperature=0.7
)
except Exception as e:
print(f"Error in TestingAgent: {e}")
return prompt
# Access response attributes
test_code = response.choices[0].message.content
# Append test code to the original code
code += "\n\n# Test cases\n" + test_code
# Update README with testing instructions
readme += "\n## Testing\nInstructions on how to run the tests."
# Update the prompt
prompt['code'] = code
prompt['readme'] = readme
return prompt
```
---
By implementing the `ProjectManagerAgent` and updating your agents accordingly, your program will now end when the project is truly complete, rather than relying on a maximum number of iterations. This approach ensures that all project requirements are met before completion.
Feel free to adjust the agents' prompts and processing logic to better suit your specific needs.
o1-preview