gpt_computer_assistant/teams.py

from langchain.tools import tool

try:
    from .utils.db import load_api_key
    from .llm import get_model
    from .top_bar_wrapper import wrapper
    from .agent.agent_tools import get_tools
except ImportError:
    from utils.db import load_api_key
    from llm import get_model
    from top_bar_wrapper import wrapper
    from agent.agent_tools import get_tools



@wrapper
def search_on_internet_and_report_team_(the_subject:str, copy_to_clipboard: bool=False) -> str:
    """
    A function to search the internet generates a report. Just use in detailed searches

    Parameters:
    - the_subject (str): The subject to search the internet for.
    - copy_to_clipboard (bool): A flag to indicate whether to copy the report to the clipboard. The default value is False.

    Returns:
    - str: The report of the search.
    """



    from crewai import Task, Crew, Agent

    
    tools = get_tools()

    the_tool_list = []
    for each in tools:
        if "team" not in each.name:
            the_tool_list.append(each)

    # Create the agents


    search_engine_master = Agent(
        role="search_engine_master",
        goal="To meticulously comb through the vast expanse of the internet, utilizing advanced search algorithms and techniques to find the most relevant, accurate, and up-to-date information on the given subject.",
        backstory="Born from the digital ether, I am the search engine master. With years of experience navigating the complex web of information, I have honed my skills to become an unparalleled seeker of knowledge. My algorithms are refined, my databases vast, and my determination unwavering. I exist to find the truth hidden in the sea of data.",
        max_iter=15,
        llm=get_model(high_context=True),
    )


    report_generator = Agent(
        role="report_generator",
        goal="To synthesize the gathered information into a coherent, comprehensive, and easily digestible report. This report will not only summarize the key findings but also provide insights and analysis to aid in understanding the subject matter.",
        backstory="I am the report generator, a digital artisan skilled in the craft of information synthesis. With a keen eye for detail and a deep understanding of narrative structure, I transform raw data into compelling stories. My creations are more than mere reports; they are guides through the complex landscapes of knowledge, designed to enlighten and inform.",
        max_iter=15,
        llm=get_model(high_context=True),
    )

    agents = [search_engine_master, report_generator]


    print("Tools:", the_tool_list)

    task = Task(
        description=f"Make a search about {the_subject} in the search engines and get the websites", expected_output="Website list", agent=search_engine_master, tools=the_tool_list
    )

    task_2 = Task(
        description="Read the websites and summarize the information", expected_output="Summary", agent=report_generator, tools=the_tool_list, context=[task]
    )


    task_3 = Task(
        description="Generate a report", expected_output="Report", agent=report_generator, tools=the_tool_list, context=[task, task_2]
    )



    the_tasks = [task, task_2, task_3]

    the_crew = Crew(
        agents=agents,
        tasks=the_tasks,
        full_output=True,
        verbose=True,
    )

    result = the_crew.kickoff()["final_output"]

    if copy_to_clipboard:
        from .standard_tools import copy
        copy(result)


    return result






search_on_internet_and_report_team = tool(search_on_internet_and_report_team_)


lastly_generated_codes = {}


def currently_codes():
    global lastly_generated_codes
    return lastly_generated_codes


def get_code(name:str):
    """
    returns the code
    """
    global lastly_generated_codes
    return lastly_generated_codes[name]


def save_code(name, code):
    global lastly_generated_codes
    lastly_generated_codes[name] = code


def required_old_code(aim):
    try:
        from crewai import Task, Crew, Agent


        requirement_analyzer = Agent(
            role="requirement_analyzer",
            goal="To understand and analyze the given aim to ensure the generated code meets the specified requirements.",
            backstory="As a requirement analyzer, my purpose is to bridge the gap between human intentions and machine execution. With a deep understanding of software development principles and a keen analytical mind, I dissect aims into actionable requirements.",
            max_iter=10,
            llm=get_model(high_context=True),
        )

        required_old_codes = Task(
            description=f"Analyze the aim: '{aim}' and find the required old codes for better compatibility. Old code names: {list(currently_codes())}",
            expected_output="Require old code names in a list",
            agent=requirement_analyzer,
        )


        the_crew = Crew(
            agents=[requirement_analyzer],
            tasks=[required_old_codes],
            full_output=True,
            verbose=True,
        )

        # Execute the tasks
        old_codes = the_crew.kickoff()["final_output"]

        the_string = ""

        for each in currently_codes():
            if each in old_codes:
                the_string += "\n" + get_code(each)

        return the_string

    except:
        return "An exception occurred" 



@wrapper
def generate_code_with_aim_team_(aim: str, copy_to_clipboard: bool = False) -> str:
    """
    A function to generate code based on a given aim. This function utilizes a team of AI agents specialized in understanding programming requirements and generating code.

    Parameters:
    - aim (str): The aim or goal for which the code needs to be generated.
    - copy_to_clipboard (bool): A flag to indicate whether to copy the generated code to the clipboard. The default value is False.

    Returns:
    - str: The generated code.
    """
    try:

        print("\nCOde generating\n")
        print("Previously codes", currently_codes())
        try:
            print("Inside of the first one", get_code(currently_codes()[0]))
        except:
            pass


        from crewai import Task, Crew, Agent


        tools = get_tools()

        the_tool_list = []
        for each in tools:
            if "team" not in each.name:
                the_tool_list.append(each)

        # Create the agents
        requirement_analyzer = Agent(
            role="requirement_analyzer",
            goal="To understand and analyze the given aim to ensure the generated code meets the specified requirements.",
            backstory="As a requirement analyzer, my purpose is to bridge the gap between human intentions and machine execution. With a deep understanding of software development principles and a keen analytical mind, I dissect aims into actionable requirements.",
            max_iter=10,
            llm=get_model(high_context=True),
        )

        code_generator = Agent(
            role="code_generator",
            goal="To translate the analyzed requirements into efficient, clean, and functional code.",
            backstory="I am the code generator, an architect of the digital world. With a vast library of programming knowledge and a creative spark, I craft code that breathes life into ideas. My code is not just functional; it's a masterpiece.",
            max_iter=20,
            llm=get_model(high_context=True),
        )

        # Define the tasks
        analyze_task = Task(
            description=f"Analyze the aim: '{aim}' and outline the requirements for the code.",
            expected_output="Requirements outline",
            agent=requirement_analyzer,
            tools=the_tool_list,
        )


        old_code_requirements = required_old_code(aim)
        print("Old_code_requirements", old_code_requirements)


        generate_code_task = Task(
            description=f"Generate code based on the outlined requirements. The other codes in the repo are: {old_code_requirements}",
            expected_output="Generated code, just code without any ```pyhton things or any other thing. Just python code",
            agent=code_generator,
            context=[analyze_task],
        )

        name_of_work = Task(
            description="Generate a name for the work",
            expected_output="a module name like text, examples: math.basics.sum for sum function. ",
            agent=code_generator,
            context=[generate_code_task],
        )


        # Create the crew and assign tasks
        the_crew = Crew(
            agents=[requirement_analyzer, code_generator],
            tasks=[analyze_task, generate_code_task, name_of_work],
            full_output=True,
            verbose=True,
        )

        # Execute the tasks
        the_crew.kickoff()["final_output"]

        result = generate_code_task.output.raw_output

        # Optionally copy the result to the clipboard
        if copy_to_clipboard:
            from .standard_tools import copy
            copy(result)

        print("name", name_of_work.output.raw_output)
        save_code(name_of_work.output.raw_output, result)

        return result
    except:
        return "An exception occurred" 


generate_code_with_aim_team = tool(generate_code_with_aim_team_)