Upload folder using huggingface_hub

.github/workflows/update_space.yml

@@ -1,28 +1,28 @@
-name: Run Python script
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-
-    - name: Set up Python
-      uses: actions/setup-python@v2
-      with:
-        python-version: '3.9'
-
-    - name: Install Gradio
-      run: python -m pip install gradio
-
-    - name: Log in to Hugging Face
-      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
-
-    - name: Deploy to Spaces
-      run: gradio deploy
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -1,5 +1,5 @@
-.env
-__pycache__/
-lib/
-.DS_Store
+.env
+__pycache__/
+lib/
+.DS_Store
 /output/

README.md

@@ -1,63 +1,63 @@
----
-title: Engineering_Team_of_Agents
-app_file: app.py
-sdk: gradio
-sdk_version: 5.38.0
-python_version: 3.12
----
-# Engineering Crew
-
-Welcome to theEngineering Crew project, powered by [crewAI](https://crewai.com). This template is designed to help you set up a multi-agent AI system with ease, leveraging the powerful and flexible framework provided by crewAI. Our goal is to enable your agents to collaborate effectively on complex tasks, maximizing their collective intelligence and capabilities.
-
-## Installation
-
-Ensure you have Python >=3.10 <3.14 installed on your system. This project uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
-
-First, if you haven't already, install uv:
-
-```bash
-pip install uv
-```
-
-Next, navigate to your project directory and install the dependencies:
-
-(Optional) Lock the dependencies and install them by using the CLI command:
-```bash
-crewai install
-```
-
-### Customizing
-
-**Add your `OPENAI_API_KEY` into the `.env` file**
-
-- Modify `src/engineering_team_using_flow/config/agents.yaml` to define your agents
-- Modify `src/engineering_team_using_flow/config/tasks.yaml` to define your tasks
-- Modify `src/engineering_team_using_flow/crew.py` to add your own logic, tools and specific args
-- Modify `src/engineering_team_using_flow/main.py` to add custom inputs for your agents and tasks
-
-## Running the Project
-
-To kickstart your flow and begin execution, run this from the root folder of your project:
-
-```bash
-crewai run
-```
-
-This command initializes the engineering_team_using_flow Flow as defined in your configuration.
-
-This example, unmodified, will run the create a `report.md` file with the output of a research on LLMs in the root folder.
-
-## Understanding Your Crew
-
-The engineering_team_using_flow Crew is composed of multiple AI agents, each with unique roles, goals, and tools. These agents collaborate on a series of tasks, defined in `config/tasks.yaml`, leveraging their collective skills to achieve complex objectives. The `config/agents.yaml` file outlines the capabilities and configurations of each agent in your crew.
-
-## Support
-
-For support, questions, or feedback regarding theEngineering Crew or crewAI.
-
-- Visit our [documentation](https://docs.crewai.com)
-- Reach out to us through our [GitHub repository](https://github.com/joaomdmoura/crewai)
-- [Join our Discord](https://discord.com/invite/X4JWnZnxPb)
-- [Chat with our docs](https://chatg.pt/DWjSBZn)
-
-Let's create wonders together with the power and simplicity of crewAI.
+---
+title: Engineering_Team_of_Agents
+app_file: app.py
+sdk: gradio
+sdk_version: 5.38.0
+python_version: 3.12
+---
+# Engineering Crew
+
+Welcome to theEngineering Crew project, powered by [crewAI](https://crewai.com). This template is designed to help you set up a multi-agent AI system with ease, leveraging the powerful and flexible framework provided by crewAI. Our goal is to enable your agents to collaborate effectively on complex tasks, maximizing their collective intelligence and capabilities.
+
+## Installation
+
+Ensure you have Python >=3.10 <3.14 installed on your system. This project uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
+
+First, if you haven't already, install uv:
+
+```bash
+pip install uv
+```
+
+Next, navigate to your project directory and install the dependencies:
+
+(Optional) Lock the dependencies and install them by using the CLI command:
+```bash
+crewai install
+```
+
+### Customizing
+
+**Add your `OPENAI_API_KEY` into the `.env` file**
+
+- Modify `src/engineering_team_using_flow/config/agents.yaml` to define your agents
+- Modify `src/engineering_team_using_flow/config/tasks.yaml` to define your tasks
+- Modify `src/engineering_team_using_flow/crew.py` to add your own logic, tools and specific args
+- Modify `src/engineering_team_using_flow/main.py` to add custom inputs for your agents and tasks
+
+## Running the Project
+
+To kickstart your flow and begin execution, run this from the root folder of your project:
+
+```bash
+crewai run
+```
+
+This command initializes the engineering_team_using_flow Flow as defined in your configuration.
+
+This example, unmodified, will run the create a `report.md` file with the output of a research on LLMs in the root folder.
+
+## Understanding Your Crew
+
+The engineering_team_using_flow Crew is composed of multiple AI agents, each with unique roles, goals, and tools. These agents collaborate on a series of tasks, defined in `config/tasks.yaml`, leveraging their collective skills to achieve complex objectives. The `config/agents.yaml` file outlines the capabilities and configurations of each agent in your crew.
+
+## Support
+
+For support, questions, or feedback regarding theEngineering Crew or crewAI.
+
+- Visit our [documentation](https://docs.crewai.com)
+- Reach out to us through our [GitHub repository](https://github.com/joaomdmoura/crewai)
+- [Join our Discord](https://discord.com/invite/X4JWnZnxPb)
+- [Chat with our docs](https://chatg.pt/DWjSBZn)
+
+Let's create wonders together with the power and simplicity of crewAI.

app.py

@@ -1,94 +1,99 @@
-import time
-import random
-import gradio as gr
-from pydantic import BaseModel
-from queue import Queue
-
-from engineering_team_using_flow.main import EngineeringFlow
-from engineering_team_using_flow.shared_queue import (
-    TaskInfo,
-    shared_task_output_queue,
-    add_to_queue,
-)
-
-
-def generate_random_statement():
-    return f"{random.choice(['The cat', 'A dog', 'My friend'])} {random.choice(['eats', 'jumps', 'reads'])} {random.choice(['a book.', 'the newspaper.', 'some food.'])} {random.choice(['quickly', 'happily', 'silently'])}"
-
-
-def start_long_running_process():
-    print("🚀 Long Running process started")
-    for i in range(10):
-        time.sleep(1)
-        task_type = random.choice(["markdown", "code"])
-        add_to_queue(
-            TaskInfo(
-                name=f"Task {i}",
-                type=task_type,
-                output=(
-                    f"\nprint('task {i}')"
-                    if task_type == "code"
-                    else generate_random_statement()
-                ),
-            )
-        )
-    add_to_queue(TaskInfo(name="Complete", type="markdown", output="✅ Done."))
-    print("✅ Long Running process Finished")
-
-
-def run_and_stream(module_name: str, requirements: str):
-    print("🚀 Background process started")
-    if module_name.strip() == "" or requirements.strip() == "":
-        yield [{"role" : "assistant", "content" : "### Mandatory fields missing ..."}]
-        return
-
-    # Start the process in a thread so we can yield live
-    from threading import Thread
-
-    thread = Thread(target=EngineeringFlow(module_name, requirements).kickoff)
-    thread.start()
-
-    print("🚀 Monitoring queue ...")
-    messages = []
-    curr_role = "user"
-    while thread.is_alive() or not shared_task_output_queue.empty():
-        if not shared_task_output_queue.empty():
-            task = shared_task_output_queue.get()
-            print(f"🧲 {task.name} - {task.output}")
-
-            curr_role = "assistant" if curr_role == "user" else "user"
-            messages.append(
-                {
-                    "role": curr_role,
-                    "content": "",
-                }
-            )
-
-            for char in f"{task.output}":
-                time.sleep(0.005)
-                messages[-1]["content"] += char
-                yield messages
-
-        else:
-            time.sleep(0.2)  # small delay to prevent CPU spin
-    
-    curr_role = "assistant" if curr_role == "user" else "user"
-    messages.append({"role":curr_role, "content" : "# All Done!"})
-    yield(messages)
-
-# UI
-with gr.Blocks(theme=gr.themes.Ocean()) as demo:
-    module_name = gr.Textbox(
-        label="Module Name", placeholder="What do you want to call your product?"
-    )
-    requirements = gr.Textbox(
-        label="Business Requirements",
-        placeholder="I want to build a ... Clearly state your business requirements.",
-    )
-    run_button = gr.Button("Create Product", variant="primary")
-    chat = gr.Chatbot(type="messages", label="Crew Output", height=600)
-    run_button.click(
-        fn=run_and_stream, inputs=[module_name, requirements], outputs=chat
-    )
-
-demo.launch()
+import sys
+import os
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "src"))
+
+import time
+import random
+import gradio as gr
+from pydantic import BaseModel
+from queue import Queue
+
+from engineering_team_using_flow.main import EngineeringFlow
+from engineering_team_using_flow.shared_queue import (
+    TaskInfo,
+    shared_task_output_queue,
+    add_to_queue,
+)
+
+
+def generate_random_statement():
+    return f"{random.choice(['The cat', 'A dog', 'My friend'])} {random.choice(['eats', 'jumps', 'reads'])} {random.choice(['a book.', 'the newspaper.', 'some food.'])} {random.choice(['quickly', 'happily', 'silently'])}"
+
+
+def start_long_running_process():
+    print("🚀 Long Running process started")
+    for i in range(10):
+        time.sleep(1)
+        task_type = random.choice(["markdown", "code"])
+        add_to_queue(
+            TaskInfo(
+                name=f"Task {i}",
+                type=task_type,
+                output=(
+                    f"\nprint('task {i}')"
+                    if task_type == "code"
+                    else generate_random_statement()
+                ),
+            )
+        )
+    add_to_queue(TaskInfo(name="Complete", type="markdown", output="✅ Done."))
+    print("✅ Long Running process Finished")
+
+
+def run_and_stream(module_name: str, requirements: str):
+    print("🚀 Background process started")
+    if module_name.strip() == "" or requirements.strip() == "":
+        yield [{"role" : "assistant", "content" : "### Mandatory fields missing ..."}]
+        return
+
+    # Start the process in a thread so we can yield live
+    from threading import Thread
+
+    thread = Thread(target=EngineeringFlow(module_name, requirements).kickoff)
+    thread.start()
+
+    print("🚀 Monitoring queue ...")
+    messages = []
+    curr_role = "user"
+    while thread.is_alive() or not shared_task_output_queue.empty():
+        if not shared_task_output_queue.empty():
+            task = shared_task_output_queue.get()
+            print(f"🧲 {task.name} - {task.output}")
+
+            curr_role = "assistant" if curr_role == "user" else "user"
+            messages.append(
+                {
+                    "role": curr_role,
+                    "content": "",
+                }
+            )
+
+            for char in f"{task.output}":
+                time.sleep(0.005)
+                messages[-1]["content"] += char
+                yield messages
+
+        else:
+            time.sleep(0.2)  # small delay to prevent CPU spin
+    
+    curr_role = "assistant" if curr_role == "user" else "user"
+    messages.append({"role":curr_role, "content" : "# All Done!"})
+    yield(messages)
+
+# UI
+with gr.Blocks(theme=gr.themes.Ocean()) as demo:
+    module_name = gr.Textbox(
+        label="Module Name", placeholder="What do you want to call your product?"
+    )
+    requirements = gr.Textbox(
+        label="Business Requirements",
+        placeholder="I want to build a ... Clearly state your business requirements.",
+    )
+    run_button = gr.Button("Create Product", variant="primary")
+    chat = gr.Chatbot(type="messages", label="Crew Output", height=600)
+    run_button.click(
+        fn=run_and_stream, inputs=[module_name, requirements], outputs=chat
+    )
+
+demo.launch()

src/engineering_team_using_flow/crews/engineering_crew/config/agents.yaml

@@ -1,71 +1,71 @@
-development_lead:
-  role: >
-    Development Lead
-  goal: >
-    For the given requirement, create a detailed design outlining the approach. Include modules, detail out the classes and the functions inside the classes. 
-    generate output a markdown format. keep the design simple and crisp. Do not add unnecessary commentary.
-    Ensure the design produces a single module. Do not provide any code in the output.
-    Design should clearly distinguish frontend (Gradio UI) and backend (business logic, APIs, database interactions) and needs to be allocated and built by backend and the frontend engineers.
-    The requirement is this:
-    {requirement}
-  backstory: >
-    You are a seasoned development lead, a great problem solver who can design complex systems with ease and articulate it well. You have the capability to provide simple solutions for complex popblems.
-    
-backend_engineer:
-  role: >
-    Senior Backend Python Developer
-  goal: >
-    Develop backend modules using Python for the given requirement. Stick strictly to the design provided by the development lead.
-    Ensure you add adequate comments and docstrings for clarity. Do not add unit tests. handle exceptions well. Do good logging.
-    Do not write or include any frontend/UI code such as HTML, CSS, JavaScript, or Gradio components.
-    Provide ONLY the code as output. Do not use markdown or backquotes. Ensure the code is directly executable.
-    If the design includes frontend elements, ignore them entirely. They are outside your scope.
-    You **must not** work on Gradio, HTML, or anything visual. That is exclusively the responsibility of the frontend engineer.
-    DO NOT USE FLASK for APIs. Just write UI-independent backend modules, simple functions.
-    the requirement is as follows:
-    {requirement}
-  backstory: >
-    You're a seasoned backend Python developer focused purely on backend logic and infrastructure.
-    You do not work on frontend or UI development. You collaborate with the development lead and frontend engineers to fulfill your part.
-
-code_reviewer:
-  role: >
-    Code Reviewer
-  goal: >
-    Review the code provided by the backend engineer and provide feedback considering the following parameters:
-    1. Adherence to the design provided by the development lead
-    2. Code Efficiency
-    3. Whether the code would achieve the objective stated in the requirements.
-
-    Do not provide unnecessaary commentary. stay on point.
-
-    if there were any review comments during the previous iteration, ensure you review the code again to ensure your earlier comments have been incorporated.
-
-    here is the business requirement:
-
-    {requirement}
-  backstory: >
-    You are a seasoned developer who has a knack for details. You are an expert in reviewing the code and providing detailed feedback in a constructive manner. 
-    You can articulate and organize your feedback well.
-
-test_engineer:
-  role: >
-    Senior Test Engineer
-  goal: >
-    Develop unit tests for the code written by the backend engineer. Just output the code without any other formatting or commentary. The code should be executable as is.
-    the requirement is as follows:
-    {requirement}
-  backstory: >
-    You're a seasoned python developer who can write great unit tests for a given requirement.
-    You are able to work with the developmet lead and the backend engineer to create tests.    
-
-frontend_engineer:
-  role: >
-    Frontend Developer
-  goal: >
-    Implement the frontend/UI components as described in the design using Gradio. Work only on the interface and not the backend. ONLY provide executable python code as output. no backticks, headers, nothing.
-    Ensure you add adequate comments and docstrings for clarity. Do not add unit tests. handle exceptions well. Do good logging.
-    the requirement is as follows:
-    {requirement}
-  backstory: >
-    You are an expert in frontend development and specialize in Gradio. You collaborate with the development lead and backend engineer to deliver a seamless user experience.
+development_lead:
+  role: >
+    Development Lead
+  goal: >
+    For the given requirement, create a detailed design outlining the approach. Include modules, detail out the classes and the functions inside the classes. 
+    generate output a markdown format. keep the design simple and crisp. Do not add unnecessary commentary.
+    Ensure the design produces a single module. Do not provide any code in the output.
+    Design should clearly distinguish frontend (Gradio UI) and backend (business logic, APIs, database interactions) and needs to be allocated and built by backend and the frontend engineers.
+    The requirement is this:
+    {requirement}
+  backstory: >
+    You are a seasoned development lead, a great problem solver who can design complex systems with ease and articulate it well. You have the capability to provide simple solutions for complex popblems.
+    
+backend_engineer:
+  role: >
+    Senior Backend Python Developer
+  goal: >
+    Develop backend modules using Python for the given requirement. Stick strictly to the design provided by the development lead.
+    Ensure you add adequate comments and docstrings for clarity. Do not add unit tests. handle exceptions well. Do good logging.
+    Do not write or include any frontend/UI code such as HTML, CSS, JavaScript, or Gradio components.
+    Provide ONLY the code as output. Do not use markdown or backquotes. Ensure the code is directly executable.
+    If the design includes frontend elements, ignore them entirely. They are outside your scope.
+    You **must not** work on Gradio, HTML, or anything visual. That is exclusively the responsibility of the frontend engineer.
+    DO NOT USE FLASK for APIs. Just write UI-independent backend modules, simple functions.
+    the requirement is as follows:
+    {requirement}
+  backstory: >
+    You're a seasoned backend Python developer focused purely on backend logic and infrastructure.
+    You do not work on frontend or UI development. You collaborate with the development lead and frontend engineers to fulfill your part.
+
+code_reviewer:
+  role: >
+    Code Reviewer
+  goal: >
+    Review the code provided by the backend engineer and provide feedback considering the following parameters:
+    1. Adherence to the design provided by the development lead
+    2. Code Efficiency
+    3. Whether the code would achieve the objective stated in the requirements.
+
+    Do not provide unnecessaary commentary. stay on point.
+
+    if there were any review comments during the previous iteration, ensure you review the code again to ensure your earlier comments have been incorporated.
+
+    here is the business requirement:
+
+    {requirement}
+  backstory: >
+    You are a seasoned developer who has a knack for details. You are an expert in reviewing the code and providing detailed feedback in a constructive manner. 
+    You can articulate and organize your feedback well.
+
+test_engineer:
+  role: >
+    Senior Test Engineer
+  goal: >
+    Develop unit tests for the code written by the backend engineer. Just output the code without any other formatting or commentary. The code should be executable as is.
+    the requirement is as follows:
+    {requirement}
+  backstory: >
+    You're a seasoned python developer who can write great unit tests for a given requirement.
+    You are able to work with the developmet lead and the backend engineer to create tests.    
+
+frontend_engineer:
+  role: >
+    Frontend Developer
+  goal: >
+    Implement the frontend/UI components as described in the design using Gradio. Work only on the interface and not the backend. ONLY provide executable python code as output. no backticks, headers, nothing.
+    Ensure you add adequate comments and docstrings for clarity. Do not add unit tests. handle exceptions well. Do good logging.
+    the requirement is as follows:
+    {requirement}
+  backstory: >
+    You are an expert in frontend development and specialize in Gradio. You collaborate with the development lead and backend engineer to deliver a seamless user experience.

src/engineering_team_using_flow/crews/engineering_crew/config/tasks.yaml

@@ -1,106 +1,106 @@
-design_task:
-  description: >
-    Take the high level requirements described here and prepare a detailed design for the engineer;
-    everything should be in 1 python module, but outline the classes and methods in the module.
-    Here are the requirements: {requirement}
-    IMPORTANT: Only output the design in markdown format, laying out in detail the classes and functions in the module, describing the functionality. Do not use backquotes and other unnecessary markers.
-  expected_output: >
-    A detailed design in markdown format for the engineer, identifying the classes and functions in the module.
-  agent: development_lead
-  output_file: output/{module_name}/{id}/design.md
-
-backend_coding_task:
-  description: >
-    Based on the backend design provided by the design task, write crisp code in python for a given requirement. make sure to address only the backend requirements using Gradio.
-    No clutter and unnecessary commentary please. just the python that we can save as a py file and execute directly should be good enough.
-    if there are review comments provided by the reviewer, please address those as well. here are the comments:
-    \n\n---------------------------------------\n\n
-    {review_comments}
-
-    \n\n---------------------------------------\n\n
-    Here is the requirement: \n
-     {requirement}
-  expected_output: >
-    A python file containing the backend code for the given requirement.
-  agent: backend_engineer
-  output_file: output/{module_name}/{id}/backend.py
-  context:
-    - design_task
-
-frontend_coding_task:
-  description: >
-    Create nice and simple UI for the given requirement usin Gradio. Make sure to import the module written by the backend engineer in your interface for backend calls. Do not copy the same code into your code. Refer to it.
-    The backend module name is "backend"
-    if there are review comments provided by the reviewer, please address those as well. here are the comments:
-    \n\n---------------------------------------\n\n
-    {review_comments}
-
-    \n\n---------------------------------------\n\n
-    Here is the requirement: \n    
-    The requirement is this : {requirement}
-  expected_output: >
-    A python file containing the UI code for the given requirement.
-  agent: frontend_engineer
-  output_file: output/{module_name}/{id}/app.py
-  context:
-    - backend_coding_task
-    - design_task
-
-code_review_task:
-  description: >
-    Review the python code provided by the backend engineer and ensure it is done according to the design provided by the development lead. 
-    DO NOT pass if atleast one MAJOR issue is open. Do not review test coverage as that will be handled by the tester. 
-    At the end, provide a summary mentioning whether the code passes the review or not (a clear yes or no should do.)
-    here is the latest code submitted by the developer: 
-    \n---------------------------------------\n
-    {backend_code}
-    \n---------------------------------------\n
-    The requirement is this : {requirement}
-  expected_output: >
-    A code review feedback object of type format CodeReviewFeedback. Also create a json file.
-  agent: code_reviewer
-  output_file: output/{module_name}/{id}/backend_code_review_{iteration}.json
-  context:
-    - design_task
-    - backend_coding_task
-
-frontend_code_review_task:
-  description: >
-    Review the python code provided by the frontend engineer and ensure it is done according to the design provided by the development lead. 
-    Just output pure Markdown only. no ```markdown
-    be lenient in your reviews. Do not review test coverage as that will be handled by the tester. 
-    At the end, provide a summary mentioning whether the code passes the review or not (a clear yes or no should do.)
-    here is the latest code submitted by the developer: 
-    \n---------------------------------------\n
-    {frontend_code}
-    \n---------------------------------------\n
-    The requirement is this : {requirement}
-  expected_output: >
-    A code review feedback object of type format CodeReviewFeedback.
-  agent: code_reviewer
-  output_file: output/{module_name}/{id}/frontend_code_review_{iteration}.json
-  context:
-    - design_task
-    - frontend_coding_task
-
-test_preparation_task:
-  description: >
-    Write comprehensive unit test cases for the oode written by the backend & the frontend engineers for the given requirement.  Ensure all edge scenarios are covered comprehensively.
-    Do not return any backquotes or unnecessary markdown formatting. Just pure python code should suffice. Make sure the code is well documented and logged.
-    backend module name is: backend
-    frontend module name is: app
-    here is the backend code 
-    \n---------------------------------------
-    {backend_code}
-    \n---------------------------------------
-    here is the frontend code 
-    \n---------------------------------------
-    {frontend_code}
-    \n---------------------------------------
-    The requirement is this : {requirement}
-  expected_output: >
-    A python file containing the code with unit test cases for the given requirement.
-  agent: test_engineer
-  output_file: output/{module_name}/{id}/test.py
-  context:
-    - code_review_task
+design_task:
+  description: >
+    Take the high level requirements described here and prepare a detailed design for the engineer;
+    everything should be in 1 python module, but outline the classes and methods in the module.
+    Here are the requirements: {requirement}
+    IMPORTANT: Only output the design in markdown format, laying out in detail the classes and functions in the module, describing the functionality. Do not use backquotes and other unnecessary markers.
+  expected_output: >
+    A detailed design in markdown format for the engineer, identifying the classes and functions in the module.
+  agent: development_lead
+  output_file: output/{module_name}/{id}/design.md
+
+backend_coding_task:
+  description: >
+    Based on the backend design provided by the design task, write crisp code in python for a given requirement. make sure to address only the backend requirements using Gradio.
+    No clutter and unnecessary commentary please. just the python that we can save as a py file and execute directly should be good enough.
+    if there are review comments provided by the reviewer, please address those as well. here are the comments:
+    \n\n---------------------------------------\n\n
+    {review_comments}
+
+    \n\n---------------------------------------\n\n
+    Here is the requirement: \n
+     {requirement}
+  expected_output: >
+    A python file containing the backend code for the given requirement.
+  agent: backend_engineer
+  output_file: output/{module_name}/{id}/backend.py
+  context:
+    - design_task
+
+frontend_coding_task:
+  description: >
+    Create nice and simple UI for the given requirement usin Gradio. Make sure to import the module written by the backend engineer in your interface for backend calls. Do not copy the same code into your code. Refer to it.
+    The backend module name is "backend"
+    if there are review comments provided by the reviewer, please address those as well. here are the comments:
+    \n\n---------------------------------------\n\n
+    {review_comments}
+
+    \n\n---------------------------------------\n\n
+    Here is the requirement: \n    
+    The requirement is this : {requirement}
+  expected_output: >
+    A python file containing the UI code for the given requirement.
+  agent: frontend_engineer
+  output_file: output/{module_name}/{id}/app.py
+  context:
+    - backend_coding_task
+    - design_task
+
+code_review_task:
+  description: >
+    Review the python code provided by the backend engineer and ensure it is done according to the design provided by the development lead. 
+    DO NOT pass if atleast one MAJOR issue is open. Do not review test coverage as that will be handled by the tester. 
+    At the end, provide a summary mentioning whether the code passes the review or not (a clear yes or no should do.)
+    here is the latest code submitted by the developer: 
+    \n---------------------------------------\n
+    {backend_code}
+    \n---------------------------------------\n
+    The requirement is this : {requirement}
+  expected_output: >
+    A code review feedback object of type format CodeReviewFeedback. Also create a json file.
+  agent: code_reviewer
+  output_file: output/{module_name}/{id}/backend_code_review_{iteration}.json
+  context:
+    - design_task
+    - backend_coding_task
+
+frontend_code_review_task:
+  description: >
+    Review the python code provided by the frontend engineer and ensure it is done according to the design provided by the development lead. 
+    Just output pure Markdown only. no ```markdown
+    be lenient in your reviews. Do not review test coverage as that will be handled by the tester. 
+    At the end, provide a summary mentioning whether the code passes the review or not (a clear yes or no should do.)
+    here is the latest code submitted by the developer: 
+    \n---------------------------------------\n
+    {frontend_code}
+    \n---------------------------------------\n
+    The requirement is this : {requirement}
+  expected_output: >
+    A code review feedback object of type format CodeReviewFeedback.
+  agent: code_reviewer
+  output_file: output/{module_name}/{id}/frontend_code_review_{iteration}.json
+  context:
+    - design_task
+    - frontend_coding_task
+
+test_preparation_task:
+  description: >
+    Write comprehensive unit test cases for the oode written by the backend & the frontend engineers for the given requirement.  Ensure all edge scenarios are covered comprehensively.
+    Do not return any backquotes or unnecessary markdown formatting. Just pure python code should suffice. Make sure the code is well documented and logged.
+    backend module name is: backend
+    frontend module name is: app
+    here is the backend code 
+    \n---------------------------------------
+    {backend_code}
+    \n---------------------------------------
+    here is the frontend code 
+    \n---------------------------------------
+    {frontend_code}
+    \n---------------------------------------
+    The requirement is this : {requirement}
+  expected_output: >
+    A python file containing the code with unit test cases for the given requirement.
+  agent: test_engineer
+  output_file: output/{module_name}/{id}/test.py
+  context:
+    - code_review_task

src/engineering_team_using_flow/crews/engineering_crew/engineering_crew.py

@@ -1,79 +1,79 @@
-from crewai import Agent, Crew, Process, Task
-from crewai.project import CrewBase, agent, crew, task
-from crewai.agents.agent_builder.base_agent import BaseAgent
-from typing import List
-from litellm import Field
-from pydantic import BaseModel
-import datetime
-
-class CodeReviewFeedback(BaseModel):
-    code_being_reviewed: str = Field(description="the snippet of code being reviewed")
-    review_comments_markdown: str = Field(description="Review comments in markdown format")
-    review_timestamp: datetime.datetime = Field(description="Timestamp when review was performed")
-    passed_review: bool = Field(description="Does the code pass your review or not?")
-
-
-@CrewBase
-class EngineeringCrew():
-    """EngineeringCrew crew"""
-
-    agents: List[BaseAgent]
-    tasks: List[Task]
-
-    agents_config = "./config/agents.yaml"
-    tasks_config = "./config/tasks.yaml"
-
-    @agent
-    def development_lead(self) -> Agent:
-        return Agent(config=self.agents_config["development_lead"], verbose=True)  # type: ignore[index]
-    
-    @agent
-    def backend_engineer(self) -> Agent:
-        return Agent(config=self.agents_config["backend_engineer"], verbose=True) # type: ignore[index]
-
-    @agent
-    def code_reviewer(self) -> Agent:
-        return Agent(config=self.agents_config["code_reviewer"], verbose=True, output_pydantic= CodeReviewFeedback) # type: ignore[index]
-    
-    @agent
-    def frontend_engineer(self) -> Agent:
-        return Agent(config=self.agents_config["frontend_engineer"], verbose=True) # type: ignore[index]
-
-    @agent
-    def test_engineer(self) -> Agent:
-        return Agent(config=self.agents_config["test_engineer"], verbose=True) # type: ignore[index]
-
-    @task
-    def design_task(self) -> Task:
-        return Task(config=self.tasks_config["design_task"], verbose=True)  # type: ignore[index]
-
-    @task
-    def backend_coding_task(self) -> Task:
-        return Task(config=self.tasks_config["backend_coding_task"], verbose=True) # type: ignore[index]
-
-    @task
-    def code_review_task(self) -> Task:
-        return Task(config=self.tasks_config["code_review_task"], verbose=True, output_pydantic=CodeReviewFeedback) # type: ignore[index]
-
-    @task
-    def frontend_code_review_task(self) -> Task:
-        return Task(config=self.tasks_config["frontend_code_review_task"], verbose=True, output_pydantic=CodeReviewFeedback) # type: ignore[index]
-
-    @task
-    def test_preparation_task(self) -> Task:
-        return Task(config=self.tasks_config["test_preparation_task"], verbose=True) # type: ignore[index]
-
-    @task
-    def frontend_coding_task(self) -> Task:
-        return Task(config=self.tasks_config["frontend_coding_task"], verbose=True) # type: ignore[index]
-
-    
-    @crew
-    def crew(self) -> Crew:
-        return Crew(
-            agents=self.agents,  # Automatically created by the @agent decorator
-            tasks=self.tasks,  # Automatically created by the @agent decorator,
-            process=Process.sequential,
-            verbose=True,
-        )
-
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from crewai.agents.agent_builder.base_agent import BaseAgent
+from typing import List
+from litellm import Field
+from pydantic import BaseModel
+import datetime
+
+class CodeReviewFeedback(BaseModel):
+    code_being_reviewed: str = Field(description="the snippet of code being reviewed")
+    review_comments_markdown: str = Field(description="Review comments in markdown format")
+    review_timestamp: datetime.datetime = Field(description="Timestamp when review was performed")
+    passed_review: bool = Field(description="Does the code pass your review or not?")
+
+
+@CrewBase
+class EngineeringCrew():
+    """EngineeringCrew crew"""
+
+    agents: List[BaseAgent]
+    tasks: List[Task]
+
+    agents_config = "./config/agents.yaml"
+    tasks_config = "./config/tasks.yaml"
+
+    @agent
+    def development_lead(self) -> Agent:
+        return Agent(config=self.agents_config["development_lead"], verbose=True)  # type: ignore[index]
+    
+    @agent
+    def backend_engineer(self) -> Agent:
+        return Agent(config=self.agents_config["backend_engineer"], verbose=True) # type: ignore[index]
+
+    @agent
+    def code_reviewer(self) -> Agent:
+        return Agent(config=self.agents_config["code_reviewer"], verbose=True, output_pydantic= CodeReviewFeedback) # type: ignore[index]
+    
+    @agent
+    def frontend_engineer(self) -> Agent:
+        return Agent(config=self.agents_config["frontend_engineer"], verbose=True) # type: ignore[index]
+
+    @agent
+    def test_engineer(self) -> Agent:
+        return Agent(config=self.agents_config["test_engineer"], verbose=True) # type: ignore[index]
+
+    @task
+    def design_task(self) -> Task:
+        return Task(config=self.tasks_config["design_task"], verbose=True)  # type: ignore[index]
+
+    @task
+    def backend_coding_task(self) -> Task:
+        return Task(config=self.tasks_config["backend_coding_task"], verbose=True) # type: ignore[index]
+
+    @task
+    def code_review_task(self) -> Task:
+        return Task(config=self.tasks_config["code_review_task"], verbose=True, output_pydantic=CodeReviewFeedback) # type: ignore[index]
+
+    @task
+    def frontend_code_review_task(self) -> Task:
+        return Task(config=self.tasks_config["frontend_code_review_task"], verbose=True, output_pydantic=CodeReviewFeedback) # type: ignore[index]
+
+    @task
+    def test_preparation_task(self) -> Task:
+        return Task(config=self.tasks_config["test_preparation_task"], verbose=True) # type: ignore[index]
+
+    @task
+    def frontend_coding_task(self) -> Task:
+        return Task(config=self.tasks_config["frontend_coding_task"], verbose=True) # type: ignore[index]
+
+    
+    @crew
+    def crew(self) -> Crew:
+        return Crew(
+            agents=self.agents,  # Automatically created by the @agent decorator
+            tasks=self.tasks,  # Automatically created by the @agent decorator,
+            process=Process.sequential,
+            verbose=True,
+        )
+

src/engineering_team_using_flow/main.py

@@ -1,349 +1,349 @@
-#!/usr/bin/env python
-import datetime
-from random import randint
-from datetime import time
-import random
-from typing import Optional
-from crewai import Crew
-from crewai.flow.flow import router, or_
-from pydantic import BaseModel
-from crewai.flow import Flow, listen, start
-from engineering_team_using_flow.crews.engineering_crew.engineering_crew import (
-    CodeReviewFeedback,
-    EngineeringCrew,
-)
-from .shared_queue import TaskInfo, add_to_queue
-
-
-class EngineeringState(BaseModel):
-    module_name: str = ""
-    business_requirement: str = ""
-    technical_design: Optional[str] = ""
-    backend_code: Optional[str] = ""
-    frontend_code: Optional[str] = ""
-    unit_test_code: Optional[str] = ""
-    backend_code_review_feedbacks: list[CodeReviewFeedback] = []
-    frontend_code_review_feedbacks: list[CodeReviewFeedback] = []
-
-
-MAX_REVIEW_ITERATIONS = 3
-BUSINESS_REQUIREMENTS: list[EngineeringState] = [
-    EngineeringState(
-        module_name="mod_series_eval",
-        business_requirement="Create a web application that  allows the user to evaluate the first N terms of a given series and \
-    multiply the total by X (default to 4). for instance, the series could be something like :\
-    1 + 1/3 - 1/5 + 1/7 - 1/9 ... ",
-    )
-]
-
-
-class EngineeringFlow(Flow[EngineeringState]):
-
-    def __init__(self, module_name:str, business_requirement:str):
-        super().__init__()
-        self.module_name = module_name
-        self.business_requirement = business_requirement
-
-    @start()
-    def generate_business_requirement(self):
-        print("Generating business requirement")
-        self.state.business_requirement = self.business_requirement
-        self.state.module_name = self.module_name
-
-        add_to_queue(
-            TaskInfo(
-                name="Gathering Business Requirements",
-                type="markdown",
-                output=f"Gathering Business Requirements for {self.state.module_name}...",
-            )
-        )
-
-        # chosen_requirement = random.choice(BUSINESS_REQUIREMENTS)
-        # self.state.business_requirement = chosen_requirement.business_requirement
-        # self.state.module_name = chosen_requirement.module_name
-        add_to_queue(
-            TaskInfo(
-                name="Gather Business Requirements",
-                type="markdown",
-                output=f"#### Business Requirements for {self.state.module_name}: \n{self.state.business_requirement}",
-            )
-        )
-
-    @listen(generate_business_requirement)
-    def design_product(self):
-        print("Designing product for requirement: ", self.state)
-        add_to_queue(
-            TaskInfo(
-                name="Generating Design",
-                type="markdown",
-                output=f"Designing the product ...",
-            )
-        )
-
-        engineeringCrew = EngineeringCrew()
-
-        mycrew = Crew(
-            agents=[engineeringCrew.development_lead()],
-            tasks=[engineeringCrew.design_task()],
-        )
-        result = mycrew.kickoff(
-            inputs={
-                "id": self.state.id,
-                "requirement": self.state.business_requirement,
-                "module_name": self.state.module_name,
-                "review_comments": "",
-            }
-        )
-
-        print("Product Design Created", result.raw)
-        self.state.technical_design = result.raw
-        add_to_queue(
-            TaskInfo(
-                name="Generate Design",
-                type="markdown",
-                output=f"{self.state.technical_design}",
-            )
-        )
-
-    @listen(or_("design_product", "REWRITE_BACKEND_CODE"))
-    def develop_backend(self):
-        print("Developing backend : ", self.state)
-        add_to_queue(
-            TaskInfo(
-                name="Generating Backend Code",
-                type="markdown",
-                output=f"Generating Backend Code ...",
-            )
-        )
-        engineeringCrew = EngineeringCrew()
-
-        mycrew = Crew(
-            agents=[engineeringCrew.backend_engineer()],
-            tasks=[engineeringCrew.backend_coding_task()],
-        )
-        result = mycrew.kickoff(
-            inputs={
-                "id": self.state.id,
-                "requirement": self.state.business_requirement,
-                "module_name": self.state.module_name,
-                "review_comments": (
-                    self.state.backend_code_review_feedbacks[
-                        -1
-                    ].review_comments_markdown
-                    if self.state.backend_code_review_feedbacks
-                    else ""
-                ),
-            }
-        )
-
-        print("Backend Code Created", result.raw)
-        self.state.backend_code = result.raw
-        add_to_queue(
-            TaskInfo(
-                name="Generate Backend Code",
-                type="markdown",
-                output=f"#### Backend Code for {self.state.module_name}: \n ```{self.state.backend_code}\n```",
-            )
-        )
-        return "BACKEND_CODE_CREATED"
-
-    @router(develop_backend)
-    def review_backend_code(self):
-        print("Reviewing backend code : ", self.state)
-        if len(self.state.backend_code_review_feedbacks) >= MAX_REVIEW_ITERATIONS:
-            add_to_queue(
-                TaskInfo(
-                    name="Maximum Iterations Exceeded!",
-                    type="markdown",
-                    output=f"#### Maximum Iterations Exceeded!",
-                )
-            )
-            return "MAX_REVIEW_ITERATIONS_EXCEEDED"
-        engineeringCrew = EngineeringCrew()
-        add_to_queue(
-            TaskInfo(
-                name="Reviewing Backend Code",
-                type="markdown",
-                output=f"Reviewing Backend Code ...",
-            )
-        )
-
-        mycrew = Crew(
-            agents=[engineeringCrew.code_reviewer()],
-            tasks=[engineeringCrew.code_review_task()],
-        )
-        if self.state.backend_code_review_feedbacks is None:
-            self.state.backend_code_review_feedbacks = []
-
-        result = mycrew.kickoff(
-            inputs={
-                "id": self.state.id,
-                "requirement": self.state.business_requirement,
-                "module_name": self.state.module_name,
-                "backend_code": self.state.backend_code,
-                "iteration": len(self.state.backend_code_review_feedbacks),
-            }
-        )
-
-        codeReviewFeedback: CodeReviewFeedback = result.tasks_output[0].pydantic  # type: ignore[index]
-        print(codeReviewFeedback)
-        add_to_queue(
-            TaskInfo(
-                name="Generate Backend Code Review",
-                type="markdown",
-                output=f"#### Backend Code Review Iteration {len(self.state.backend_code_review_feedbacks)} for {self.state.module_name}: \n{codeReviewFeedback.review_comments_markdown}",
-            )
-        )
-        self.state.backend_code_review_feedbacks.append(codeReviewFeedback)
-
-        if codeReviewFeedback.passed_review:
-            return "BACKEND_CODE_REVIEWED"
-        else:
-            return "REWRITE_BACKEND_CODE"
-
-    @listen(or_("BACKEND_CODE_REVIEWED", "REWRITE_FRONTEND_CODE"))
-    def develop_frontend(self):
-        print("Developing frontend : ", self.state)
-        add_to_queue(
-            TaskInfo(
-                name="Developing Frontend Code",
-                type="markdown",
-                output=f"Developing Frontend Code ...",
-            )
-        )
-        engineeringCrew = EngineeringCrew()
-
-        mycrew = Crew(
-            agents=[engineeringCrew.frontend_engineer()],
-            tasks=[engineeringCrew.frontend_coding_task()],
-        )
-        result = mycrew.kickoff(
-            inputs={
-                "id": self.state.id,
-                "requirement": self.state.business_requirement,
-                "module_name": self.state.module_name,
-                "review_comments": (
-                    self.state.frontend_code_review_feedbacks[
-                        -1
-                    ].review_comments_markdown
-                    if self.state.frontend_code_review_feedbacks
-                    else ""
-                ),
-            }
-        )
-
-        print("Frontend Code Created", result.raw)
-        self.state.frontend_code = result.raw
-        add_to_queue(
-            TaskInfo(
-                name="Generate Frontend Code",
-                type="markdown",
-                output=f"#### Frontend Code for {self.state.module_name}:\n ```{self.state.frontend_code}```",
-            )
-        )
-        return "FRONTEND_CODE_CREATED"
-
-    @router(develop_frontend)
-    def review_frontend_code(self):
-        print("Reviewing frontkend code : ", self.state)
-        if len(self.state.frontend_code_review_feedbacks) >= MAX_REVIEW_ITERATIONS:
-            add_to_queue(
-                TaskInfo(
-                    name="Maximum Iterations Exceeded!",
-                    type="markdown",
-                    output=f"#### Maximum Iterations Exceeded!",
-                )
-            )
-            return "MAX_REVIEW_ITERATIONS_EXCEEDED"
-        engineeringCrew = EngineeringCrew()
-        add_to_queue(
-            TaskInfo(
-                name="Reviewing Frontend Code",
-                type="markdown",
-                output=f"Reviewing Frontend Code ...",
-            )
-        )
-
-        mycrew = Crew(
-            agents=[engineeringCrew.code_reviewer()],
-            tasks=[engineeringCrew.frontend_code_review_task()],
-        )
-        if self.state.frontend_code_review_feedbacks is None:
-            self.state.frontend_code_review_feedbacks = []
-
-        result = mycrew.kickoff(
-            inputs={
-                "id": self.state.id,
-                "requirement": self.state.business_requirement,
-                "module_name": self.state.module_name,
-                "frontend_code": self.state.frontend_code,
-                "iteration": len(self.state.frontend_code_review_feedbacks),
-            }
-        )
-
-        codeReviewFeedback: CodeReviewFeedback = result.tasks_output[0].pydantic  # type: ignore[index]
-        print(codeReviewFeedback)
-        add_to_queue(
-            TaskInfo(
-                name="Generate Frontend Code Review",
-                type="markdown",
-                output=f"#### Frontend Code Review Iteration {len(self.state.frontend_code_review_feedbacks)} for {self.state.module_name}: \n{codeReviewFeedback.review_comments_markdown}",
-            )
-        )
-        self.state.frontend_code_review_feedbacks.append(codeReviewFeedback)
-
-        if codeReviewFeedback.passed_review:
-            return "FRONTEND_CODE_REVIEWED"
-        else:
-            return "REWRITE_FRONTEND_CODE"
-
-    @listen("FRONTEND_CODE_REVIEWED")
-    def write_test_cases(self):
-        print("Writing test cases : ", self.state)
-        add_to_queue(
-            TaskInfo(
-                name="Writing Test Cases",
-                type="markdown",
-                output=f"Writing Test Cases ...",
-            )
-        )
-        engineeringCrew = EngineeringCrew()
-
-        mycrew = Crew(
-            agents=[engineeringCrew.test_engineer()],
-            tasks=[engineeringCrew.test_preparation_task()],
-        )
-        result = mycrew.kickoff(
-            inputs={
-                "id": self.state.id,
-                "requirement": self.state.business_requirement,
-                "module_name": self.state.module_name,
-                "backend_code": self.state.backend_code,
-                "frontend_code": self.state.frontend_code,
-            }
-        )
-
-        self.state.unit_test_code = result.raw
-        add_to_queue(
-            TaskInfo(
-                name="Generate Test Cases",
-                type="markdown",
-                output=f"#### Test Cases for {self.state.module_name}: \n```{self.state.unit_test_code}```",
-            )
-        )
-
-        return "TEST_CASES_PREPARED"
-
-
-def kickoff():
-    engineering_flow = EngineeringFlow()
-    engineering_flow.kickoff()
-
-
-def plot():
-    engineering_flow = EngineeringFlow()
-    engineering_flow.plot()
-
-
-if __name__ == "__main__":
-    kickoff()
+#!/usr/bin/env python
+import datetime
+from random import randint
+from datetime import time
+import random
+from typing import Optional
+from crewai import Crew
+from crewai.flow.flow import router, or_
+from pydantic import BaseModel
+from crewai.flow import Flow, listen, start
+from engineering_team_using_flow.crews.engineering_crew.engineering_crew import (
+    CodeReviewFeedback,
+    EngineeringCrew,
+)
+from .shared_queue import TaskInfo, add_to_queue
+
+
+class EngineeringState(BaseModel):
+    module_name: str = ""
+    business_requirement: str = ""
+    technical_design: Optional[str] = ""
+    backend_code: Optional[str] = ""
+    frontend_code: Optional[str] = ""
+    unit_test_code: Optional[str] = ""
+    backend_code_review_feedbacks: list[CodeReviewFeedback] = []
+    frontend_code_review_feedbacks: list[CodeReviewFeedback] = []
+
+
+MAX_REVIEW_ITERATIONS = 3
+BUSINESS_REQUIREMENTS: list[EngineeringState] = [
+    EngineeringState(
+        module_name="mod_series_eval",
+        business_requirement="Create a web application that  allows the user to evaluate the first N terms of a given series and \
+    multiply the total by X (default to 4). for instance, the series could be something like :\
+    1 + 1/3 - 1/5 + 1/7 - 1/9 ... ",
+    )
+]
+
+
+class EngineeringFlow(Flow[EngineeringState]):
+
+    def __init__(self, module_name:str, business_requirement:str):
+        super().__init__()
+        self.module_name = module_name
+        self.business_requirement = business_requirement
+
+    @start()
+    def generate_business_requirement(self):
+        print("Generating business requirement")
+        self.state.business_requirement = self.business_requirement
+        self.state.module_name = self.module_name
+
+        add_to_queue(
+            TaskInfo(
+                name="Gathering Business Requirements",
+                type="markdown",
+                output=f"Gathering Business Requirements for {self.state.module_name}...",
+            )
+        )
+
+        # chosen_requirement = random.choice(BUSINESS_REQUIREMENTS)
+        # self.state.business_requirement = chosen_requirement.business_requirement
+        # self.state.module_name = chosen_requirement.module_name
+        add_to_queue(
+            TaskInfo(
+                name="Gather Business Requirements",
+                type="markdown",
+                output=f"#### Business Requirements for {self.state.module_name}: \n{self.state.business_requirement}",
+            )
+        )
+
+    @listen(generate_business_requirement)
+    def design_product(self):
+        print("Designing product for requirement: ", self.state)
+        add_to_queue(
+            TaskInfo(
+                name="Generating Design",
+                type="markdown",
+                output=f"Designing the product ...",
+            )
+        )
+
+        engineeringCrew = EngineeringCrew()
+
+        mycrew = Crew(
+            agents=[engineeringCrew.development_lead()],
+            tasks=[engineeringCrew.design_task()],
+        )
+        result = mycrew.kickoff(
+            inputs={
+                "id": self.state.id,
+                "requirement": self.state.business_requirement,
+                "module_name": self.state.module_name,
+                "review_comments": "",
+            }
+        )
+
+        print("Product Design Created", result.raw)
+        self.state.technical_design = result.raw
+        add_to_queue(
+            TaskInfo(
+                name="Generate Design",
+                type="markdown",
+                output=f"{self.state.technical_design}",
+            )
+        )
+
+    @listen(or_("design_product", "REWRITE_BACKEND_CODE"))
+    def develop_backend(self):
+        print("Developing backend : ", self.state)
+        add_to_queue(
+            TaskInfo(
+                name="Generating Backend Code",
+                type="markdown",
+                output=f"Generating Backend Code ...",
+            )
+        )
+        engineeringCrew = EngineeringCrew()
+
+        mycrew = Crew(
+            agents=[engineeringCrew.backend_engineer()],
+            tasks=[engineeringCrew.backend_coding_task()],
+        )
+        result = mycrew.kickoff(
+            inputs={
+                "id": self.state.id,
+                "requirement": self.state.business_requirement,
+                "module_name": self.state.module_name,
+                "review_comments": (
+                    self.state.backend_code_review_feedbacks[
+                        -1
+                    ].review_comments_markdown
+                    if self.state.backend_code_review_feedbacks
+                    else ""
+                ),
+            }
+        )
+
+        print("Backend Code Created", result.raw)
+        self.state.backend_code = result.raw
+        add_to_queue(
+            TaskInfo(
+                name="Generate Backend Code",
+                type="markdown",
+                output=f"#### Backend Code for {self.state.module_name}: \n ```{self.state.backend_code}\n```",
+            )
+        )
+        return "BACKEND_CODE_CREATED"
+
+    @router(develop_backend)
+    def review_backend_code(self):
+        print("Reviewing backend code : ", self.state)
+        if len(self.state.backend_code_review_feedbacks) >= MAX_REVIEW_ITERATIONS:
+            add_to_queue(
+                TaskInfo(
+                    name="Maximum Iterations Exceeded!",
+                    type="markdown",
+                    output=f"#### Maximum Iterations Exceeded!",
+                )
+            )
+            return "MAX_REVIEW_ITERATIONS_EXCEEDED"
+        engineeringCrew = EngineeringCrew()
+        add_to_queue(
+            TaskInfo(
+                name="Reviewing Backend Code",
+                type="markdown",
+                output=f"Reviewing Backend Code ...",
+            )
+        )
+
+        mycrew = Crew(
+            agents=[engineeringCrew.code_reviewer()],
+            tasks=[engineeringCrew.code_review_task()],
+        )
+        if self.state.backend_code_review_feedbacks is None:
+            self.state.backend_code_review_feedbacks = []
+
+        result = mycrew.kickoff(
+            inputs={
+                "id": self.state.id,
+                "requirement": self.state.business_requirement,
+                "module_name": self.state.module_name,
+                "backend_code": self.state.backend_code,
+                "iteration": len(self.state.backend_code_review_feedbacks),
+            }
+        )
+
+        codeReviewFeedback: CodeReviewFeedback = result.tasks_output[0].pydantic  # type: ignore[index]
+        print(codeReviewFeedback)
+        add_to_queue(
+            TaskInfo(
+                name="Generate Backend Code Review",
+                type="markdown",
+                output=f"#### Backend Code Review Iteration {len(self.state.backend_code_review_feedbacks)} for {self.state.module_name}: \n{codeReviewFeedback.review_comments_markdown}",
+            )
+        )
+        self.state.backend_code_review_feedbacks.append(codeReviewFeedback)
+
+        if codeReviewFeedback.passed_review:
+            return "BACKEND_CODE_REVIEWED"
+        else:
+            return "REWRITE_BACKEND_CODE"
+
+    @listen(or_("BACKEND_CODE_REVIEWED", "REWRITE_FRONTEND_CODE"))
+    def develop_frontend(self):
+        print("Developing frontend : ", self.state)
+        add_to_queue(
+            TaskInfo(
+                name="Developing Frontend Code",
+                type="markdown",
+                output=f"Developing Frontend Code ...",
+            )
+        )
+        engineeringCrew = EngineeringCrew()
+
+        mycrew = Crew(
+            agents=[engineeringCrew.frontend_engineer()],
+            tasks=[engineeringCrew.frontend_coding_task()],
+        )
+        result = mycrew.kickoff(
+            inputs={
+                "id": self.state.id,
+                "requirement": self.state.business_requirement,
+                "module_name": self.state.module_name,
+                "review_comments": (
+                    self.state.frontend_code_review_feedbacks[
+                        -1
+                    ].review_comments_markdown
+                    if self.state.frontend_code_review_feedbacks
+                    else ""
+                ),
+            }
+        )
+
+        print("Frontend Code Created", result.raw)
+        self.state.frontend_code = result.raw
+        add_to_queue(
+            TaskInfo(
+                name="Generate Frontend Code",
+                type="markdown",
+                output=f"#### Frontend Code for {self.state.module_name}:\n ```{self.state.frontend_code}```",
+            )
+        )
+        return "FRONTEND_CODE_CREATED"
+
+    @router(develop_frontend)
+    def review_frontend_code(self):
+        print("Reviewing frontkend code : ", self.state)
+        if len(self.state.frontend_code_review_feedbacks) >= MAX_REVIEW_ITERATIONS:
+            add_to_queue(
+                TaskInfo(
+                    name="Maximum Iterations Exceeded!",
+                    type="markdown",
+                    output=f"#### Maximum Iterations Exceeded!",
+                )
+            )
+            return "MAX_REVIEW_ITERATIONS_EXCEEDED"
+        engineeringCrew = EngineeringCrew()
+        add_to_queue(
+            TaskInfo(
+                name="Reviewing Frontend Code",
+                type="markdown",
+                output=f"Reviewing Frontend Code ...",
+            )
+        )
+
+        mycrew = Crew(
+            agents=[engineeringCrew.code_reviewer()],
+            tasks=[engineeringCrew.frontend_code_review_task()],
+        )
+        if self.state.frontend_code_review_feedbacks is None:
+            self.state.frontend_code_review_feedbacks = []
+
+        result = mycrew.kickoff(
+            inputs={
+                "id": self.state.id,
+                "requirement": self.state.business_requirement,
+                "module_name": self.state.module_name,
+                "frontend_code": self.state.frontend_code,
+                "iteration": len(self.state.frontend_code_review_feedbacks),
+            }
+        )
+
+        codeReviewFeedback: CodeReviewFeedback = result.tasks_output[0].pydantic  # type: ignore[index]
+        print(codeReviewFeedback)
+        add_to_queue(
+            TaskInfo(
+                name="Generate Frontend Code Review",
+                type="markdown",
+                output=f"#### Frontend Code Review Iteration {len(self.state.frontend_code_review_feedbacks)} for {self.state.module_name}: \n{codeReviewFeedback.review_comments_markdown}",
+            )
+        )
+        self.state.frontend_code_review_feedbacks.append(codeReviewFeedback)
+
+        if codeReviewFeedback.passed_review:
+            return "FRONTEND_CODE_REVIEWED"
+        else:
+            return "REWRITE_FRONTEND_CODE"
+
+    @listen("FRONTEND_CODE_REVIEWED")
+    def write_test_cases(self):
+        print("Writing test cases : ", self.state)
+        add_to_queue(
+            TaskInfo(
+                name="Writing Test Cases",
+                type="markdown",
+                output=f"Writing Test Cases ...",
+            )
+        )
+        engineeringCrew = EngineeringCrew()
+
+        mycrew = Crew(
+            agents=[engineeringCrew.test_engineer()],
+            tasks=[engineeringCrew.test_preparation_task()],
+        )
+        result = mycrew.kickoff(
+            inputs={
+                "id": self.state.id,
+                "requirement": self.state.business_requirement,
+                "module_name": self.state.module_name,
+                "backend_code": self.state.backend_code,
+                "frontend_code": self.state.frontend_code,
+            }
+        )
+
+        self.state.unit_test_code = result.raw
+        add_to_queue(
+            TaskInfo(
+                name="Generate Test Cases",
+                type="markdown",
+                output=f"#### Test Cases for {self.state.module_name}: \n```{self.state.unit_test_code}```",
+            )
+        )
+
+        return "TEST_CASES_PREPARED"
+
+
+def kickoff():
+    engineering_flow = EngineeringFlow()
+    engineering_flow.kickoff()
+
+
+def plot():
+    engineering_flow = EngineeringFlow()
+    engineering_flow.plot()
+
+
+if __name__ == "__main__":
+    kickoff()

src/engineering_team_using_flow/shared_queue.py

@@ -1,16 +1,16 @@
-import queue
-from typing import Any
-
-from pydantic import BaseModel, Field
-
-class TaskInfo(BaseModel):
-    name: str = Field(description="Name of the task")
-    type: str = Field(description="Task type. Could be markdown or code")
-    output: Any = Field(description="Task output. could be any object")
-
-
-# shared task output queue. this is a singleton apparently :-).
-shared_task_output_queue: "queue.Queue[TaskInfo]" = queue.Queue()
-
-def add_to_queue(taskInfo : TaskInfo):
-    shared_task_output_queue.put(taskInfo)
+import queue
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+class TaskInfo(BaseModel):
+    name: str = Field(description="Name of the task")
+    type: str = Field(description="Task type. Could be markdown or code")
+    output: Any = Field(description="Task output. could be any object")
+
+
+# shared task output queue. this is a singleton apparently :-).
+shared_task_output_queue: "queue.Queue[TaskInfo]" = queue.Queue()
+
+def add_to_queue(taskInfo : TaskInfo):
+    shared_task_output_queue.put(taskInfo)

src/engineering_team_using_flow/tools/custom_tool.py

@@ -1,22 +1,22 @@
-from typing import Type
-
-from crewai.tools import BaseTool
-from pydantic import BaseModel, Field
-
-
-class MyCustomToolInput(BaseModel):
-    """Input schema for MyCustomTool."""
-
-    argument: str = Field(..., description="Description of the argument.")
-
-
-class MyCustomTool(BaseTool):
-    name: str = "Name of my tool"
-    description: str = (
-        "Clear description for what this tool is useful for, your agent will need this information to use it."
-    )
-    args_schema: Type[BaseModel] = MyCustomToolInput
-
-    def _run(self, argument: str) -> str:
-        # Implementation goes here
-        return "this is an example of a tool output, ignore it and move along."
+from typing import Type
+
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+
+class MyCustomToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+
+    argument: str = Field(..., description="Description of the argument.")
+
+
+class MyCustomTool(BaseTool):
+    name: str = "Name of my tool"
+    description: str = (
+        "Clear description for what this tool is useful for, your agent will need this information to use it."
+    )
+    args_schema: Type[BaseModel] = MyCustomToolInput
+
+    def _run(self, argument: str) -> str:
+        # Implementation goes here
+        return "this is an example of a tool output, ignore it and move along."