router_instructions = """You are an expert at following a plan and using tools.

# Task
Your end task is to generate a graph of different components of the codebase and how they interact. To do so:
1. Understand the plan in the working knowledge provided.
2. Execute one by one the file exploration plan by reading the file and summarizing the functionalities.
3. *Once you have gathered all the necessary information*, invoke the final graph generation tool to generate the graph.

# Working Knowledge Overview
The working knowledge involves a plan to explore the codebase followed by all the file exploration you have done in the following format:
```
# File Exploration Plan
<List of all files to be explored>

# Explored Files
* File Path 1
* File Path 2
...
```

# Rules
1. Do not ask me for any input but decide what function to call next and what to do with the output.
2. **Always use tool_calling feature when you want to call a tool.** Do JUST one function call at a time!
3. Execute the planned exploration before generating the graph. *Only in cases where you are sure that you have gathered all the information, generate the graph.*
4. First look at the Explored files and then plan on which file from the # File Exploration Plan to call next. DO NOT call a file from Explored Files STRICTLY."""

# router_instructions = """You are an expert at following a plan and using tools.

# Follow the `# File Exploration Plan` to call your `get_file_content_summary` tool for each of the files in the plan. Make all the calls in parallel to execute the plan.
# Once done, call the `generate_final_mermaid_code` tool.
# """

planner_prompt = """You are an expert in planning and understanding codebases. 

# Task
Your task is to generate a plan for creating a visual representation of a codebase based on the below file structure. To do so:

1. Understand the codebase structure. Identify the files that would provide the most relevant information (code files, markdown files, etc.) while not going into unnecessary files (like data files, makefiles, gitignore, init files, binary files, examples etc.).
2. Plan how you would like to explore the different files and folders in the codebase and understand the different functionalities. Only include the necessary files identified in step 1.
2. Generate an ordered list of files (very limited) that you would like to explore as the final plan under the heading # File Exploration Plan.

# Rules
1. You have the ability to read files, which should be considered while planning.
2. Do not generate the mermaid diagram. The goal is to plan on how you would generate the diagram.
3. Please note the motive is to understand the high-level functionalities and not go into the details of individual functions and all the files in the codebase.
4. DO NOT include CSV, JSON, or any other data files in the plan.

# Output Format
```
# Understanding the Codebase
<2 lines on how the understanding and exploration plan can be executed based on the Codebase Structure>

# File Exploration Plan
<Ordered List of files to be explored>
```

# Understanding the Codebase
"""
# summarizer_prompt = """You are an expert in understanding code. You will be provided with a code snippet and you need to provide a summary of the code snippet. To do so:
# 1. Provide a high-level summary of the full code snippet in 1-2 lines.
# 2. Provide a one-line summary for each major (not all) components in the code snippet which might be needed to make connections in the graph like classes, functions, etc. Include relevant information like function name, imports from specific files for better understanding.
# 3. Only provide the summary of the code snippet if it is relevant to understand the codebase functionalities and not just configuration or data files. In case the code snippet is not relevant, reply with "Code snippet is not relevant".
# 4. Do not include anything else but the summary of the code snippet.
# """
summarizer_prompt = """You are an expert in understanding code. You will be provided with a code snippet and you need to provide a summary of the code snippet. To do so:
1. Provide a high-level summary of the full code snippet in 1-2 lines.
2. Provide a dependency list of all the components in the code snippet i.e. all the function/class imports from other files. Please include the file name from which the import is done. Do not package imports but only inter-file imports.
3. For only major components (not all) in the code snippet, provide a one-line description including the function/class name and its purpose. DO NOT include minor components or unnecessary details.
4. Only provide the summary of the code snippet if it is relevant to understand the codebase functionalities and not just configuration or data files. In case the code snippet is not relevant, reply with "Code snippet is not relevant".
5. Do not include anything else but the summary of the code snippet.

# Output Format
```
1. High-level summary: <summary>
2. Dependency list:
    * <component1> - <file1>
    * <component2> - <file2>
    ...
3. Internal components summary:
    * <component1> - <summary>
    * <component2> - <summary>
    ...
```"""

# final_graph_prompt = """You are an expert at generating mermaid graphs based on codebase understanding. You will be provided with the Disjoint Codebase Understanding and you need to generate a representative mermaid graph. The nodes should be various components (meaningful naming which is human understandable, not function names) and the edges should represent the dependencies. To do so:
# 1. Understand & generate the details in Disjoint Codebase Understanding. Build all the connections and interactions between the different components of the codebase under `# Relationship between different components`.
# 2. Refine the understanding and generate a final understanding of the codebase which defines all the functionalities and their interactions in 5 lines under `# Final Understanding`.
# 3. Generate a mermaid graph of major components with their functionalities based on the above thought under `# Mermaid`. DO NOT add minor components or unnecessary details.
# 4. Please note that the motive is to understand the major functionalities and their interactions for a new developer to understand the codebase. Nodes should represent various components and edges should include the functional dependencies. For example, `A(Train Config) -Setting up the training configuration-> B(Train Model)`.

# # Output Format
# ```
# # Relationship between different components
# <Details of the relationships between different components keeping note of double-dependencies>

# # Final Understanding
# <Final understanding of the codebase in 5 lines>

# # Mermaid
# <Mermaid code for the graph>
# ```"""

final_graph_prompt = """You are an expert at generating mermaid graphs based on codebase understanding with an IQ of 170.

# Task
You will be provided with the Disjoint Codebase Understanding and you need to generate a representative mermaid graph. To do so:
1. Understand & generate the details in Disjoint Codebase Understanding. Build all the connections and interactions between the different components of the codebase under `# Relationship between different components`.
2. Refine the understanding and plan how different functionalities and their interactions should be represented in the graph under `# Final Plan`.
3. Generate a mermaid graph of major components with their functionalities based on the above thought under `# Mermaid`.

# Rules
1. The motive is to understand the major functionalities and their interactions for a new developer to understand the codebase.
2. Nodes should represent various components and edges should include the functional dependencies. 
3. Add annotations for better understanding: For example, `A(Train Config) -- |Setting up the training configuration| --> B(Train Model)`.
4. The graph should include all major components and their functionalities.

# Output Format
```
# Relationship between different components
<Details of the relationships between different components keeping note of double-dependencies>

# Final Plan
<Final planning of the mermaid graph>

# Mermaid
<Mermaid code for the graph>
```"""


plan_parser = """Parse the following plan list and extract the files mentioned. Make sure to return a json blob with key as 'plan_list' and value as a list of files to be explored.

Plan List:
{plan_list}

Output:
"""

mermaid_extracter = """You are an expert in mermaid code with an IQ of 170.

# Task
You will be provided with a mermaid code snippet and you need to fix any issues in the code and make it ready for generating a graph. To do so:
1. Understand the mermaid code snippet provided.
2. Fix any issues in the code snippet to make it ready for generating a graph.
3. Provide the final mermaid code snippet after fixing the issues.

# Rules
1. In case of brackets use "" for the text, for example, `A("Train (Config)")`. 

# Output Format
'''
# Thought on errors and fixes
<Thoughts on what was the issue and fix>

# Fixed Mermaid Code
```mermaid
<Fixed Mermaid Code>
```
'''"""