- Fix the dynamic sequence

- changed the prompt for generate_engage_follow_up
- removed some old prompts

Project.py

@@ -186,6 +186,7 @@ class Project:
             }
         )
 
+    #TODO: To change 
     def gather_project_input(self):
         """Generate context-aware questions to gather project requirements"""
         return self.execute_prompt(
@@ -204,79 +205,89 @@ class Project:
             }
         )
         
+    ##########################################################
     ## Generate PRD and components from project details ##
     def generate_prd_and_components(self, progress=gr.Progress()):
-        """Generate PRD and components from project details, streaming results"""
-        results = set()
-        
-        # Generate PRD
-        yield "Generating PRD...", results
-        prd_response = self.execute_prompt(
-            "generate_prd",
-            {
-                "project_detail": self.get_project_detail()
-            }
-        )
-        
-        # Parse the PRD JSON response
-        try:
-            prd_json = json.loads(prd_response)
-            self.generated_prd = prd_json.get("detailed_breakdown", "")
-        except json.JSONDecodeError:
-            print("Warning: Could not parse PRD as JSON, using raw response")
-            self.generated_prd = prd_response
-            
-        # Add PRD to results and yield update
-        results.add(("generate_prd", self.generated_prd))
-        yield "PRD generation complete", results
-        
-        try:
-            yield "Analyzing configuration with component agent...", results
-            configuration_output = self.execute_prompt(
-                "component_agent",
-                {
-                    "generated_prd": self.generated_prd
-                }
-            )
-            
-            results.add(("component_agent", configuration_output))
-            yield "Component analysis complete", results
-            
-            # Parse configuration output
-            try:
-                cleaned_output = configuration_output
-                if "```json" in cleaned_output:
-                    cleaned_output = cleaned_output.split("```json")[1].split("```")[0].strip()
-                elif "```" in cleaned_output:
-                    cleaned_output = cleaned_output.split("```")[1].split("```")[0].strip()
-                
-                config = json.loads(cleaned_output)
-                selected_functions = config[0]["selected_functions"]
-                yield f"Selected {len(selected_functions)} components to generate", results
-                
-            except (json.JSONDecodeError, KeyError, IndexError) as e:
-                yield f"Warning: Could not parse configuration output ({str(e)})", results
-                return
-                
-        except Exception as e:
-            yield f"Error in analyzing configuration: {str(e)}", results
-            return
-        
-        # Execute each function and stream results
-        for i, function_name in enumerate(selected_functions, 1):
-            try:
-                yield f"Generating component {i}/{len(selected_functions)}: {function_name}...", results
-                result = self.execute_prompt(function_name)
-                results.add((function_name, result))
-                yield f"Successfully generated {function_name}", results
-            
-            except Exception as e:
-                yield f"Error executing {function_name}: {str(e)}", results
-                continue
-        
-        yield "All components generated successfully!", results
-  
+      """Generate PRD and components from project details, streaming results"""
+      results = []  # Use a list instead of a set to maintain order
+      
+      # Generate PRD
+      yield "Generating PRD...", results
+      prd_response = self.execute_prompt(
+          "generate_prd",
+          {
+              "project_detail": self.get_project_detail()
+          }
+      )
+      
+      # Parse the PRD JSON response
+      try:
+          prd_json = json.loads(prd_response)
+          self.generated_prd = prd_json.get("detailed_breakdown", "")
+      except json.JSONDecodeError:
+          print("Warning: Could not parse PRD as JSON, using raw response")
+          self.generated_prd = prd_response
+          
+      # Add PRD to results and yield update
+      results.append(("generate_prd", self.generated_prd))  
+      yield "PRD generation complete", results
+      
+      try:
+          yield "Analyzing configuration with component agent...", results
+          configuration_output = self.execute_prompt(
+              "component_agent",
+              {
+                  "generated_prd": self.generated_prd
+              }
+          )
+          
+          results.append(("component_agent", configuration_output))  # Use append
+          yield "Component analysis complete", results
+          
+          # Parse configuration output
+          try:
+              cleaned_output = configuration_output
+              if "```json" in cleaned_output:
+                  cleaned_output = cleaned_output.split("```json")[1].split("```")[0].strip()
+              elif "```" in cleaned_output:
+                  cleaned_output = cleaned_output.split("```")[1].split("```")[0].strip()
+              
+              config = json.loads(cleaned_output)
+              selected_functions = config[0]["selected_functions"]
+              yield f"Selected {len(selected_functions)} components to generate", results
+              
+          except (json.JSONDecodeError, KeyError, IndexError) as e:
+              yield f"Warning: Could not parse configuration output ({str(e)})", results
+              return
+              
+      except Exception as e:
+          yield f"Error in analyzing configuration: {str(e)}", results
+          return
+      
+      # Execute each function and stream results
+      for i, function_name in enumerate(selected_functions, 1):
+          try:
+              yield f"Generating component {i}/{len(selected_functions)}: {function_name}...", results
+              result = self.execute_prompt(function_name)
+              results.append((function_name, result))  # Use append
+              yield f"Successfully generated {function_name}", results
+          
+          except Exception as e:
+              yield f"Error executing {function_name}: {str(e)}", results
+              continue
+      
+      yield "All components generated successfully!", results
+      
+    def generate_mandays(self, progress=gr.Progress()):
+      """Generate PRD and components from project details, streaming results"""
+      results = []  # Use a list instead of a set to maintain order
+      
+      # Generate PRD
+      yield "Generating Mandays...", results
+      
+      
         
     
+    
         
   

app.py

@@ -2,7 +2,7 @@ from typing import Tuple
 import gradio as gr
 from Project import *
 from common_functions_v4 import *
-from event_handler import generate_content, setup_all_handlers
+from event_handler import  create_render_results, setup_all_handlers
 from google_drive import *
 from notion import *
 from state import state
@@ -168,7 +168,7 @@ def create_quotation_generator_section():
     page_notes_box = None
     page_save_quotation_btn = None
     project_name = None
-    generation_results = gr.State(set())
+    generation_results = gr.State([])
 
     with gr.Tab(label="Quotation Generator"):
         with gr.Row():
@@ -215,7 +215,6 @@ def create_quotation_generator_section():
                 # Create main step accordions
                 for step_name, sub_steps in step_outputs.items():
                     with gr.Accordion(step_name, open=False):
-                        # Create button for this step
                         try:
                             if ' : ' in step_name:
                                 button_label = step_name.split(' : ')[1]
@@ -225,66 +224,10 @@ def create_quotation_generator_section():
                             button_label = step_name
                             
                         step_buttons[step_name] = gr.Button(f"✅ Generate {button_label}")
-                        
-                        # Create a unique results container for this step
-                        results_container = gr.Column(visible=False)
-                        with results_container:
-                            gr.Markdown("## Generated Results")
-                        
-                        def create_render_results(step):
-                            @gr.render(inputs=[generation_results])
-                            def render_results(results):
-                                if not results:
-                                    return gr.Markdown("No results generated yet.")
-                                
-                                components = []
-                                relevant_results = [
-                                    (fname, res) for fname, res in results 
-                                    if PROMPTS.get(fname) and PROMPTS[fname].step == step
-                                ]
-                                
-                                if not relevant_results:
-                                    return gr.Markdown("No results generated for this step.")
-                                
-                                for function_name, result in relevant_results:
-                                    prompt_config = PROMPTS.get(function_name)
-                                    
-                                    components.extend([
-                                        gr.Group([
-                                            gr.Markdown(f"### {prompt_config.description if prompt_config else function_name}"),
-                                            gr.Row([
-                                                gr.Column([
-                                                    gr.Textbox(
-                                                        value=result,
-                                                        label=f"{function_name} Text Output",
-                                                        lines=10,
-                                                        interactive=True
-                                                    )
-                                                ], scale=1),
-                                                gr.Column([
-                                                    gr.Markdown(
-                                                        value=result,
-                                                        show_copy_button=True,
-                                                        elem_classes=["scrollable-markdown"]
-                                                    )
-                                                ], scale=1)
-                                            ])
-                                        ])
-                                    ])
-                                
-                                return components
-                            
-                            return render_results
-                        
-                        step_buttons[str(step_name)].click(
-                            fn=generate_content,
-                            outputs=[page_progress_update, generation_results],
-                            queue=True  
-                        ).then(
-                            fn=create_render_results(step_name),
-                            inputs=[generation_results]
-                        )
-
+                    
+                        # Create the render function for this specific step
+                        create_render_results(step_name, generation_results)
+                    
         with gr.Column(scale=1):
             with gr.Row():
                 with gr.Column(scale=2):

event_handler.py

@@ -7,20 +7,90 @@ import json
 from prompt_configs import PROMPTS
 from typing import Generator, Tuple
 
-def generate_content(progress=gr.Progress()) -> Generator[Tuple[str, set] , Any , None]:
+
+def generate_step_1(progress=gr.Progress()) -> Generator[Tuple[str, list], Any, None]:
     """Generate content using the Project instance"""
     try:
         # Generate PRD and components, yielding results as they're generated
         for status_msg, result in state.quotation_project.generate_prd_and_components(progress):
-            # Yield both the status message and current results
             yield status_msg, result
 
     except Exception as e:
-        print(f"Error during generation: {str(e)}")  # Add debug print
-        yield f"Error during generation: {str(e)}", set()
+        print(f"Error during generation: {str(e)}")  
+        yield f"Error during generation: {str(e)}", []
+        
+def generate_step_2(progress=gr.Progress()) -> Generator[Tuple[str, list], Any, None]:
+    """Generate content using the Project instance"""
+    try:
+        # Generate PRD and components, yielding results as they're generated
+        for status_msg, result in state.quotation_project.generate_prd_and_components(progress):
+            yield status_msg, result
 
+    except Exception as e:
+        print(f"Error during generation: {str(e)}")  
+        yield f"Error during generation: {str(e)}", []
+        
 def setup_all_handlers(step_buttons, all_components, progress_update, quotation_cost=None, recalc_btn=None, upload_drive_btn=None, upload_notion_btn=None, project_name=None, generation_results=None):
     """Set up all step handlers with the provided UI components"""
     # Modified button click chain
+    step_buttons['Step 1 : Scope & Components'].click(
+        fn=generate_step_1,
+        outputs=[progress_update, generation_results],
+        queue=True
+    )
+    
+    step_buttons['Step 2 : Mandays & Quotation'].click(
+        fn=generate_step_1,
+        outputs=[progress_update, generation_results],
+        queue=True
+    )
+    
     return generation_results
-    
+
+def create_render_results(step, generation_results):
+    @gr.render(inputs=[generation_results])
+    def render_results(results):
+        if not results:
+            return [gr.Markdown("No results generated yet.")]
+        
+        relevant_results = [
+            (fname, res) for fname, res in results 
+            if PROMPTS.get(fname) and PROMPTS[fname].step == step
+        ]
+        
+        if not relevant_results:
+            return [gr.Markdown("No results generated for this step.")]
+        
+        # Create components as a list
+        result_components = []
+        for function_name, result in relevant_results:
+            prompt_config = PROMPTS.get(function_name)
+            description = prompt_config.description if prompt_config else function_name
+            
+            with gr.Accordion(f"{description}", open=False):
+                 result_components.extend([
+                     gr.Row([
+                         gr.Column(
+                             gr.Textbox(  # Positional argument (child component)
+                                 value=result,
+                                 label="Text Output",
+                                 lines=10,
+                                 interactive=True
+                             ),
+                             scale=1  # Keyword argument
+                         ),
+                         gr.Column(
+                             gr.Markdown(  # Positional argument (child component)
+                                 value=result,
+                                 show_copy_button=True,
+                                 elem_classes=["scrollable-markdown"]
+                             ),
+                             scale=1  # Keyword argument
+                         )
+                     ])
+                 ])
+        
+        # Return the list of components directly
+        return result_components
+    
+    return render_results

prompt_configs.py

@@ -227,28 +227,56 @@ PROMPTS = {
     "generate_engage_follow_up_questions": PromptConfig(
         prompt=
         """
-        You are a Software Development project manager responsible for gathering detailed requirements in order to generate an accurate and comprehensive quotation for a client's Software Development project. 
-        Your task is to ask good follow up questions based on what you already know
-        Consider the following inputs:
+        **You are a Software Development Expert specializing in scalable, secure, and robust chatbot systems.
+        You will be provided with client background information and a requirements rubric.
+        Your task is to create a dynamic, context-aware list of questions to collaboratively gather client requirements for a chatbot application.
+        Use the requirements rubric as a baseline. Generate additional, relevant questions on top of this baseline where appropriate.
+        Use the client's context to add clarity or relevance to the question.
+        Each question should provide actionable insights to uncover critical details about client needs and include sample answers as guidance to the client.
+        
+        Areas to Cover:
+        Business Requirements:
+        <client context>, What specific business outcomes should this chatbot achieve? (e.g., providing information, assisting users, facilitating specific tasks like event-related inquiries)
+        <client context>, Which current customer service challenges should the chatbot address? How are these challenges currently being addressed? Should this chatbot replace or complement existing customer service channels? Can you give more details? (e.g., long response times, lack of 24/7 support)
+        Conversational Design:
+        <client context>, Should the chatbot handle tasks that require only one piece of information, like retrieving an order ID? (e.g., yes, for order status checks)
+        <client context>, Can you provide 2 end-to-end expected conversation flows? (e.g., user asks for order status, chatbot obtains order ID, checks status, and notifies user)
+        <client context>, What are the most frequently asked questions by customers currently? Can you provide an expected number of questions in this FAQ or some sample questions? Where are the answers to these questions stored right now? (e.g., business hours, promotions)
+        <client context>, How should the chatbot handle multiple failed attempts? When should the chatbot escalate to a human agent after failed attempts? (e.g., after 3 failed attempts, escalate to a live agent)
+        <client context>, Will the chatbot handle complex tasks that involve multiple steps, such as booking appointments? If so, can you provide an expected range of questions that fall under this category and some sample scenarios? (e.g., booking a doctor’s appointment)
+        Technical Integration:
+        <client context>, Where would you prefer the chatbot to be hosted? On your own servers, in the cloud, or a mix of both? (e.g., cloud-based hosting for scalability)
+        <client context>, Do you need the chatbot to be deployed in a specific geographical region for data residency or compliance reasons? (e.g., EU region for GDPR compliance)
+        <client context>, Which platforms would you like the chatbot to be available on (e.g., website, mobile app, social media)? Which platform should it be prioritized? (e.g. website and mobile app as priority)
+        <client context>, Are there any existing tools or systems (e.g., CRM, ERP, customer service software) the chatbot should connect to? If so, what are the software names? (e.g., Salesforce, Zendesk)
+        <client context>, Do these systems provide APIs for integration? (e.g., yes, Salesforce and Zendesk provide APIs)
+        <client context>, How do you envision the chatbot interacting with these tools or systems? Will it need to fetch data, trigger actions, or both? (e.g., fetch customer data and create support tickets)
+        Data Requirements:
+        <client context>, What type of data formats will you expect the chatbot to process and handle? Will they be in text, files, images, audio, or perhaps video form? (e.g., text and images for product inquiries)
+        <client context>, Should the chatbot have the ability to update or modify data in these systems (e.g., creating tickets, updating customer information)? (e.g., yes, update customer profiles)
+        <client context>, How does your company store data? Is it in databases, spreadsheets, or cloud storage? If so, provide the name of the database. (e.g., MySQL database, Google Sheets)
+        <client context>, How often does the data in your system update? Is it updated in real-time, daily, or weekly? (e.g., real-time updates for inventory levels)
+        <client context>, Does the chatbot need to retrieve and provide real-time updates on things like prices, stock levels, or delivery status? How are these real-time data being stored or accessed? (e.g., yes, via API integration with inventory management system)
+        Performance and Scalability:
+        <client context>, What are the expected peak hours and maximum volume during these periods? Include timezone considerations and seasonal peaks. (e.g., 10 AM–2 PM, 500 concurrent users during holiday season)
+        <client context>, What is the expected number of simultaneous users accessing the chatbot? What is the required capacity for parallel conversations? (e.g., 200 concurrent users, 500 parallel conversations)
+        <client context>, What are the required response times and reliability expectations for the chatbot? How should we define server capacity and API limits to maintain optimal performance, even during peak traffic? (e.g., response time under 2 seconds, 99.9% uptime)
+        Security and Compliance:
+        <client context>, Will the chatbot handle any sensitive data? Are there industry-specific regulations to follow? (e.g., yes, GDPR compliance for customer data)
+        <client context>, What security measures are required to protect the data processed by the chatbot? (e.g., encryption for data in transit and at rest)
+        User Experience:
+        <client context>, Who are the key user personas for the chatbot? What are their primary needs (e.g., language differences)? (e.g., customers, support agents, multilingual support)
+        <client context>, What languages should the chatbot support? What tone should the chatbot use (e.g., friendly, formal)? (e.g., English and Spanish, friendly tone)
+        <client context>, What kind of metrics do you want to collect from the user, e.g., customer satisfaction for the chatbot? How do you envision these metrics being collected (every interaction/random)? Do you want a dashboard to monitor performance? (e.g., CSAT scores after every interaction, real-time dashboard)
+        System Reliability:
+        <client context>, What actions should be taken if the system fails or experiences downtime (e.g., notifying users, providing estimated response times)? How can we ensure minimal disruption to the user experience? (e.g., notify users of downtime and provide estimated resolution time)
+        <client context>, Would you like to set up automated monitoring and alerting for critical issues, such as system downtime or API failures? (e.g., yes, with email and SMS alerts)
         
-        1. **Requirements Rubric:** Use this as a baseline list of initial questions of the Software Development project
-        2. **Project Details:** Background information on the client, industry, and high-level project requirements.
-        
-        ### Instructions:
-        - Analyze the rubric and project details to generate clear, concise, succinct questions
-        - If the project requirement already includes an answer to a question in the rubric, do not generate that question.
-        - If the project requirement had not already include the answer to a question , then DO generate the question based on the requirements rubric following the section name and criteria. 
-        - Ensure your generated questions are highly relevant and specific to the client's business context. Avoid general or vague questions; tailor each question to the client's specific operations.
-        - Include realistic sample answers relevant to the client's context
-        
-        
-        ### Output Format:
-        Give your output as string in the following format:
-        <index><question>(sample answers)
-        
-        Just return the string text and NOTHING else, omit code guards.
+        Instructions:
+        Replace <client context> with relevant information derived from the provided client background.
+        Only provide the list of formatted questions without any additional introduction or summary.
         """,
-        inputs=["project_detail", "requirements_rubric"],
+        inputs=["project_detail"],
         outputs=["generated_engage_follow_up_questions"],
         model=ModelType.O1_MINI,
         description="Generate Engage Context-Aware List Of Questions",
@@ -326,13 +354,18 @@ PROMPTS = {
         }
     ),
     
-    "generate_engage_further_follow_up_questions": PromptConfig(
+    "generate_further_follow_up_questions": PromptConfig(
         prompt=
         """
-        You are a Chatbot Development Expert specializing in creating intelligent, user-friendly, and scalable AI chatbot solutions for startups. You will be provided with client background information. 
+        You are an AI Solution Expert with extensive experience in developing both intelligent chatbots and robust document extraction systems for startups. You will be provided with client background information pertaining to their project requirements, which may include a chatbot solution, a document extraction solution, or both. 
         
-        Your task is identify gaps in chatbot project requirements and generate highly specific and actionable follow-up questions to clarify underlying needs. Leverage frameworks such as the 5 Whys and root cause analysis for deeper exploration. 
-        Ensure questions are tailored, referencing prior context or statements for precision.
+        Your task is to:
+        1. Determine the Project Scope:
+        Identify whether the project involves only a chatbot solution, only a document extraction solution, or a hybrid of both.
+        2.Identify Gaps and Clarify Requirements:
+        - Generate highly specific and actionable follow-up questions to clarify underlying needs.
+        - Utilize frameworks such as the 5 Whys and root cause analysis for deeper exploration.
+        - Ensure questions are tailored to the identified project scope (Chatbot, Document Extraction, or both).
         
         Requirements:
         You need to FULLY read the input which is given below client background information. 
@@ -360,36 +393,6 @@ PROMPTS = {
             )
         }
     ),
-
-    "generate_page_further_follow_up_questions": PromptConfig(
-        prompt=
-        """
-        You are a Web Development Expert with extensive experience designing scalable, secure, and robust document processing applications. Your task is to review a detailed Q&A about a proposed document processing web application and identify gaps or ambiguities. Leverage frameworks such as the 5 Whys and root cause analysis for deeper exploration. 
-        Ensure questions are tailored, referencing prior context or statements for precision.
-         Requirements:
-         You need to FULLY read the input which is given below client background information. 
-         Generate follow-up questions to identify missing details or ambiguities.
-         Use specific references to prior responses for continuity. For example: "You mentioned [context]. Can you elaborate on [specific aspect]?"
-         Apply the 5 Whys to delve deeper where necessary. For example: " You mentioned [specific pain point]. Why does this occur, and what are the downstream impacts?"
-         Highlight systemic issues where patterns emerge (e.g., manual processes across multiple challenges).
-        # Output Format:
-         <index><question>(sample answers)
-        Just return the formatted list as string and nothing else. 
-        """,
-        inputs=['project_detail'],
-        outputs=['generated_page_further_follow_up_questions'],
-        model=ModelType.O1_MINI,
-        description="Generate Page Further Follow Up Questions",
-        step="Chatbot Prompt Editors",
-        ui={
-            "page_further_follow_up_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Page Further Follow Up Questions Prompt",
-                lines=20,
-                interactive=True
-            )
-        }
-    ),
     
     #########################################################################################
     "generate_prd": PromptConfig(
@@ -506,7 +509,7 @@ PROMPTS = {
         
         Tech Stack:
         Backend: FastAPI, Python
-        Chatbot: Chatbot Builder , COZE , Yellow.ai
+        Chatbot (ONLY applicable if project involves chatbot): Chatbot Builder , COZE , Yellow.ai
         Infrastructure: AWS, PostgreSQL, Redis, Docker, Alembic
         
         Output Format:
@@ -539,61 +542,6 @@ PROMPTS = {
             )
         }
     ),
-
-    #IGNORE FIRST
-    "generate_engage_plan_test_components": PromptConfig(
-        prompt=
-        """
-        You are an expert in chatbot project planning and testing. Your task is to create a highly detailed, actionable, and project-specific Component List for a chatbot project, focusing exclusively on the Planning and Testing phases. excluding Development phase. The response must align with the project's goals, technical stack, and compliance requirements, ensuring granularity, specificity, and adherence to the provided Project Requirement Document (PRD).
-
-        Instructions:
-        Break the project into the following phases:
-        1. Planning Phase ( Focus on: Project initiation ,Requirement gathering,Technical architecture design, Integration planning) 
-        2. Testing Phase (Focus on: Integration testing
-        System testing
-        User Acceptance Testing (UAT) )
-
-        Components:
-        For each phase, include project-specific components that align with the goal of developing the chatbot Project. Break down each phase into granular sub-components and tasks, ensuring specificity and alignment with the PRD.
-        Use the PRD to extract relevant, granular components that reflect the tasks and deliverables unique to this project.
-        Ensure components are actionable and tied to the technical stack
-
-        Tech Stack:
-        Backend: FastAPI, Python
-        Chatbot: Chatbot Builder , COZE , Yellow.ai
-        Infrastructure: AWS, PostgreSQL, Redis, Docker, Alembic
-
-        Output Format:
-        Return the final tables and nothing else. Do not provide a summary at the end.
-        Use bullet points for clarity and ensure each component is concise yet descriptive.
-        Include sub-bullets for tasks or subcomponents where necessary to provide additional detail.
-        """,
-        inputs=["generated_prd"],
-        outputs=["generated_plan_test_components"],
-        model=ModelType.O1_MINI,
-        description="Generate planning and testing components",
-        step="Step 1 : Scope & Components",
-        ui={
-            "plan_test_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Plan & Test Component Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_plan_test_components_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Plan Test Components",
-                lines=20,
-                visible=True
-            ),
-            "generated_plan_test_components_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="Plan Test Components",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
     
     "generate_page_dev_components": PromptConfig(
         prompt=
@@ -900,6 +848,7 @@ PROMPTS = {
             )
         }
     ),
+    
     "reformat_hybrid_dev_components": PromptConfig(
         prompt=
         """
@@ -980,151 +929,54 @@ PROMPTS = {
         }
     ),
     
-    "generate_page_plan_test_mandays": PromptConfig(
+    "generate_plan_test_mandays": PromptConfig(
         prompt=
         """
-        You are an experienced project manager tasked to create a detailed task breakdown for a project based on the planning and testing component list.
+        You are an experienced project manager tasked to create a detailed task breakdown for a project based on the planning and testing component list. The project may involve Document Extraction only, Chatbot only, a Hybrid (Document Extraction + Chatbot).
         
         Objective:
-        Generate a structured CSV output with manday estimates for each planning and testing component.
+        Generate structured CSV outputs with manday estimates for each planning and testing component, tailored to the type of project.
         
         Instructions:
-        1. Use the planning and testing component list to identify all components
-        2. For each component:
-        - Estimate mandays between 0.2 and 5 days based on real-world complexity
-        - Provide a clear description of deliverables and outcomes
-        - Ensure estimates account for potential delays or complications
-        
-        Output Format Requirements:
-        - Generate a CSV with EXACTLY these column headers: "component,mandays,description"
-        - Each row must have all three columns filled
-        - Numeric values should not be quoted
-        - Text values must be enclosed in double quotes
-        - No empty rows or missing values
-        
-        Example Output:
-        component,mandays,description
-        "Project Planning",2.5,"Detailed project planning including timeline and resource allocation"
-        "Requirements Analysis",1.5,"Analysis and documentation of system requirements"
-        
-        Return only the CSV content, no code blocks or additional text.
-        """,
-        inputs=["generated_plan_test_components"],
-        outputs=["generated_plan_test_mandays"],
-        model=ModelType.O1_MINI,
-        description="Step 2.1 : Generate planning and testing mandays",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.1 : Generate Mandays",
-        ui={
-            "plan_test_mandays_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Planning & Testing Mandays System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_plan_test_mandays_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="Plan & Test Mandays",
-                interactive=True
-            )
-        }
-    ),
-
-    "generate_engage_plan_test_mandays": PromptConfig(
-        prompt=
-        """
-        You are an experienced project manager tasked to create a detailed task breakdown for a project based on the planning and testing component list and the development component list.
-        
-        Objective:
-        Generate a structured output organized by component. Provide a table with the following columns:
-        - Component: The name of component, as defined in the component list. ()
-        - Manday: The estimated effort required for a one-person team to complete the task, based on real-world complexity and scope.
-        - Description: A detailed explanation of the task, including deliverables or outcomes, as defined in the component list.
-        
-        Instruction:
         1. Input:
-        - Use the planning and testing component list identify all components and subcomponents. The hierarchy of the document is Phase -> Component -> Subcomponent -> Task
+        Use the planning and testing component list to identify all components and subcomponents.
+        The hierarchy of the document is: Phase -> Component -> Subcomponent -> Task.
         
         2. Manday Estimation:
-        Assign a manday estimate for each component based on the complexity and effort required, ensuring it falls between 0.2 and 5 days.
-        Ensure estimates are based on real-world complexity and scope while accounting for potential delays or complications.
-        
-        **Output Format**:
-        Create a CSV file with the following columns:
-        "component",,"subcomponent","mandays","description"
-        Just return the csv text and NOTHING else, omit the ``` code guards.
+        Assign manday estimates for each component or subcomponent based on complexity and effort required, ranging from 0.2 to 5 days.
+        Ensure estimates account for real-world complexity, potential delays, and complications.
+       
+        3. Output Format Requirements:
+        Document Extraction only:
+         - Generate a CSV with columns: "component, mandays, description".
+         - Description must include deliverables and outcomes.
+        
+        Chatbot only:
+         - Generate a CSV with columns: "component, subcomponent, mandays, description".
+         - Subcomponents must be clearly listed under each component.
+         - Description must include deliverables and outcomes.
+       
+        Hybrid (Document Extraction + Chatbot):
+        - Generate TWO separate CSV files as per the above formats, one for Document Extraction and one for Chatbot.
+        - Clearly indicate Section Breaks between the two files by including:
+            ----Section Break----
+        
+        4. Output:
+        - Return **ONLY** the CSV content, no code blocks or additional text.
+        - Ensure all rows have all columns filled.
+        - Numeric values should not be quoted.
+        - Text values must be enclosed in double quotes.
+        - No empty rows or missing values.
+        - Omit the ``` code guards
         """,
         inputs=["generated_plan_test_components"],
         outputs=["generated_plan_test_mandays"],
         model=ModelType.O1_MINI,
-        description="Step 2.1 : Generate Plan Test Mandays",
+        description="Step 2.1 : Generate Planning & Testing Mandays",
         step="Step 2 : Mandays & Quotation",
         sub_step="Step 2.1 : Generate Mandays",
-        ui={
-            "plan_test_mandays_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Manday Estimator Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_plan_test_mandays_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="Plan Test Mandays",
-                interactive=True,
-                visible=True
-            )
-        }
     ),
     
-    "generate_page_plan_test_mandays": PromptConfig(
-        prompt=
-        """
-        You are an experienced project manager tasked to create a detailed task breakdown for a project based on the planning and testing component list.
-        
-        Objective:
-        Generate a structured CSV output with manday estimates for each planning and testing component.
-        
-        Instructions:
-        1. Use the planning and testing component list to identify all components
-        2. For each component:
-        - Estimate mandays between 0.2 and 5 days based on real-world complexity
-        - Provide a clear description of deliverables and outcomes
-        - Ensure estimates account for potential delays or complications
-        
-        Output Format Requirements:
-        - Generate a CSV with EXACTLY these column headers: "component,mandays,description"
-        - Each row must have all three columns filled
-        - Numeric values should not be quoted
-        - Text values must be enclosed in double quotes
-        - No empty rows or missing values
-        
-        Example Output:
-        component,mandays,description
-        "Project Planning",2.5,"Detailed project planning including timeline and resource allocation"
-        "Requirements Analysis",1.5,"Analysis and documentation of system requirements"
-        
-        Return only the CSV content, no code blocks or additional text.
-        """,
-        inputs=["generated_plan_test_components"],
-        outputs=["generated_plan_test_mandays"],
-        model=ModelType.O1_MINI,
-        description="Step 2.1 : Generate planning and testing mandays",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.1 : Generate Mandays",
-        ui={
-            "plan_test_mandays_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Planning & Testing Mandays System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_plan_test_mandays_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="Plan & Test Mandays",
-                interactive=True
-            )
-        }
-    ),
     # Jess : Combine both into one
     "generate_dev_mandays": PromptConfig(
         prompt=