- make output display dynamically

Project.py

@@ -92,6 +92,7 @@ class Project:
         'dev_mandays_output_id': lambda self: self.dev_mandays_output_id,
     }
 
+    #Execute prompt with given input variables
     def execute_prompt(self, prompt_name: str, input_variables: Dict[str, Any] = None) -> str:
         """Execute a prompt with given input variables"""
         if prompt_name not in PROMPTS:
@@ -202,4 +203,79 @@ class Project:
                 "project_detail": self.get_project_detail()
             }
         )
-        
+        
+    ## Generate PRD and components from project details ##
+    def generate_prd_and_components(self, progress=gr.Progress()):
+        """Generate PRD and components from project details, yielding results one by one"""
+        
+        print("\nGenerating PRD...")
+        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
+            
+        # Yield PRD result
+        yield ("generate_prd", self.generated_prd)
+        
+        try:
+            print("\nAnalyzing configuration with component agent...")
+            configuration_output = self.execute_prompt(
+                "component_agent",
+                {
+                    "generated_prd": self.generated_prd
+                }
+            )
+            
+            # Print the raw configuration output for debugging
+            print("\nRaw configuration output:")
+            print(configuration_output)
+            
+            # Try to 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"]
+                print(f"\nSelected functions: {selected_functions}")
+                
+            except (json.JSONDecodeError, KeyError, IndexError) as e:
+                print(f"Warning: Could not parse configuration output ({str(e)}),")
+                print(f"Attempted to parse: {cleaned_output}")
+                return
+                
+        except Exception as e:
+            print(f"Error in analyzing configuration: {str(e)}")
+            return
+        
+        # Execute each function and yield results one by one
+        for function_name in selected_functions:
+            try:
+                print(f"\nExecuting {function_name}...")
+                result = self.execute_prompt(function_name)
+                print(f"Successfully generated result for {function_name}")
+                yield (function_name, result)
+            
+            except Exception as e:
+                print(f"Error executing {function_name}: {str(e)}")
+                yield (function_name, f"Error: {str(e)}")
+                continue
+
+  
+        
+    
+        
+  

app.py

@@ -2,17 +2,17 @@ from typing import Tuple
 import gradio as gr
 from Project import *
 from common_functions_v4 import *
+from event_handler import setup_all_handlers
 from google_drive import *
 from notion import *
 from state import state
-from page_prompts_config import PROMPTS, ModelType, UIComponentType, UIConfig, PromptConfig
+from prompt_configs import *
 from typing import Dict, Any, Tuple
 import pandas as pd
 from io import StringIO
-from event_handlers import setup_all_handlers
 import importlib
-import page_prompts_config
-importlib.reload(page_prompts_config) 
+import prompt_configs
+importlib.reload(prompt_configs) 
 
 
 def create_ui_component(config: UIConfig, prompt: str = None) -> Any:
@@ -40,7 +40,7 @@ def create_ui_component(config: UIConfig, prompt: str = None) -> Any:
         )
     return None
 
-def create_section_components(prompt_config: PromptConfig) -> Dict[str, Any]:
+def create_prompt_editor_components(prompt_config: PromptConfig) -> Dict[str, Any]:
     components = {}
     
     with gr.Row():
@@ -86,7 +86,7 @@ def create_section_components(prompt_config: PromptConfig) -> Dict[str, Any]:
                             PROMPTS[prompt_key].prompt = new_prompt.strip()
                             
                             # Read current file content
-                            with open("page_prompts_config.py", "r", encoding='utf-8') as f:
+                            with open("prompt_config.py", "r", encoding='utf-8') as f:
                                 content = f.read()
                             
                             # Find the start of the prompt section
@@ -135,11 +135,11 @@ def create_section_components(prompt_config: PromptConfig) -> Dict[str, Any]:
                             )
                             
                             # Write back to file
-                            with open("page_prompts_config.py", "w", encoding='utf-8') as f:
+                            with open("prompt_config.py", "w", encoding='utf-8') as f:
                                 f.write(new_content)
                             
                             # Reload the PROMPTS module to update in-memory state
-                            PROMPTS = page_prompts_config.PROMPTS
+                            PROMPTS = prompt_configs.PROMPTS
                             
                             return "✅ Prompt updated successfully"
                             
@@ -155,57 +155,63 @@ def create_section_components(prompt_config: PromptConfig) -> Dict[str, Any]:
                     
                     components[editor_key] = editor
                     components[f"{editor_key}_save_status"] = save_status
-                    
-    # Create output components in two columns
-    with gr.Row():
-        text_key = next((k for k in prompt_config.ui.keys() if k.endswith('_text')), None)
-        markdown_key = next((k for k in prompt_config.ui.keys() if k.endswith('_markdown')), None)
+    
+    return components
+
+def create_dynamic_section_components(prompt_config: PromptConfig) -> Dict[str, Any]:
+    """Create UI components for displaying generated outputs"""
+    components = {}
+    
+    # Create text and markdown components for outputs
+    for output in prompt_config.outputs:
+        # Replace accordion with a simple heading
+        gr.Markdown(f"### {prompt_config.description}")
         
-        if text_key and markdown_key:
-            # Left column for textbox
+        with gr.Row():
             with gr.Column(scale=1):
-                text_component = create_ui_component(
-                    prompt_config.ui[text_key]
+                # Text component with function name as key
+                components[f"{output}_text"] = gr.Textbox(
+                    label="Text Output",
+                    lines=10,
+                    interactive=False,
+                    visible=True
                 )
-                if text_component:  # Only add if component was created
-                  components[text_key] = text_component
-                  
-            # Right column for markdown
+            
             with gr.Column(scale=1):
-                markdown_component = create_ui_component(
-                    prompt_config.ui[markdown_key]
-                )
-                if markdown_component:  # Only add if component was created
-                   components[markdown_key] = markdown_component
-                
-                        # Set up the dynamic update only if both components exist
-            if text_key in components and markdown_key in components:
-                components[text_key].change(
-                    fn=lambda x: x,
-                    inputs=[components[text_key]],
-                    outputs=[components[markdown_key]]
+                # Markdown component with function name as key
+                components[f"{output}_markdown"] = gr.Markdown(
+                    value="",
+                    visible=True,
+                    show_copy_button=True,
+                    elem_classes=["scrollable-markdown"]
                 )
-    
-    # Then create DataFrame components each in their own row
-    for key, config in prompt_config.ui.items():
-        if config.component_type == UIComponentType.DATAFRAME:
-            with gr.Row():
-                components[key] = create_ui_component(config)
-    
+        
+       # We no longer need to store an accordion component
+        # Instead, create a group to maintain the same structure for visibility control
+        with gr.Group() as group:
+            pass
+        components[f"{output}_group"] = group
+     
     return components
 
 def create_quotation_generator_section():
+    # Initialize all variables at the start
     quotation_cost = None
     page_recalc_btn = None
     page_progress_update = None
-    
+    page_upload_drive_btn = None
+    page_upload_notion_btn = None
+    page_notes_box = None
+    page_save_quotation_btn = None
+    project_name = None
+
     with gr.Tab(label="Quotation Generator"):
         with gr.Row():
             with gr.Column(scale=2):
                 gr.Markdown("## ⚠️ Instructions #2")
                 for instruction in [
-                    "1. **Edit System Prompt**: Edit the system's prompt as you wish.",
-                    "2. **Generate Output**: Proceed to click generate once prompt is edited.",
+                    "1. **Edit System Prompt**: Navigate to the System Prompts tab to edit prompts.",
+                    "2. **Generate Output**: Click generate once ready.",
                     "3. **Upload Final Documentation**: Give a project name and click upload to Google Drive or Notion",
                     "4. **Recalculate Cost**: Recalculate the cost if you want to change the mandays estimate"
                 ]:
@@ -216,66 +222,58 @@ def create_quotation_generator_section():
 
         with gr.Row():
             with gr.Column(scale=4):
-                prompt_steps = {}
-                sub_steps = {}
+                # Organize steps and their outputs
+                step_outputs = {}
                 for prompt_key, prompt_config in PROMPTS.items():
-                    # Skip prompts that are chatbot editors
                     if prompt_config.step == "Chatbot Prompt Editors":
                         continue
+                    
                     step = prompt_config.step
                     sub_step = prompt_config.sub_step
-                    if step and step.strip():
-                        if step not in prompt_steps:
-                            prompt_steps[step] = []
-                        prompt_steps[step].append(prompt_key)
-                        # Track sub-steps if they exist
-                        if sub_step:
-                            if step not in sub_steps:
-                                sub_steps[step] = {}
-                            if sub_step not in sub_steps[step]:
-                                sub_steps[step][sub_step] = []
-                            sub_steps[step][sub_step].append(prompt_key)
+                    
+                    if step not in step_outputs:
+                        step_outputs[step] = {}
+                    
+                    if sub_step:
+                        if sub_step not in step_outputs[step]:
+                            step_outputs[step][sub_step] = []
+                        step_outputs[step][sub_step].append(prompt_key)
+                    else:
+                        if "main" not in step_outputs[step]:
+                            step_outputs[step]["main"] = []
+                        step_outputs[step]["main"].append(prompt_key)
 
                 all_components = {}
                 step_buttons = {}
 
-                for step_name, prompt_keys in prompt_steps.items():
-                    with gr.Accordion(step_name, open=False):
-                        if "Step 2" in step_name:
-                            with gr.Row():
-                                with gr.Column(scale=4):
-                                    # Group components by sub-step
-                                    for sub_step, sub_step_prompts in sub_steps.get(step_name, {}).items():
-                                        # Create button for this sub-step
-                                        button_label = sub_step.split(' : ')[1] if ' : ' in sub_step else sub_step
-                                        step_buttons[sub_step] = gr.Button(f"✅ {button_label}" )
-                                        
-                                        with gr.Accordion(sub_step, open=False):
-                                            for i, prompt_key in enumerate(sub_step_prompts, 1):
-                                                if prompt_key in PROMPTS:
-                                                    with gr.Accordion(f"{i}. {PROMPTS[prompt_key].description}", open=False):
-                                                        components = create_section_components(PROMPTS[prompt_key])
-                                                        all_components[prompt_key] = components
-                                
-                                with gr.Column(scale=1):
-                                    quotation_cost = gr.Textbox(label="Cost Summary", lines=3, interactive=False)
-                                    page_recalc_btn = gr.Button("Recalculate Cost")
-                                    page_notes_box = gr.Textbox(
-                                        label="Notes", 
-                                        lines=3, 
-                                        placeholder="Add your notes here..."
-                                    )
-                                    page_save_quotation_btn = gr.Button("Save Quotation with Note")
-                        else:
-                            # Regular step button for non-Step 2
-                            button_label = step_name.split(' : ')[1] if ' : ' in step_name else step_name
-                            step_buttons[step_name] = gr.Button(f"✅ Generate {button_label}" )
+                # 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]
+                            else:
+                                button_label = step_name
+                        except Exception:
+                            button_label = step_name
                             
+                        step_buttons[step_name] = gr.Button(f"✅ Generate {button_label}")
+                        
+                        # Create components for outputs
+                        for sub_step, prompt_keys in sub_steps.items():
                             for prompt_key in prompt_keys:
                                 if prompt_key in PROMPTS:
-                                    with gr.Accordion(f"{PROMPTS[prompt_key].description}", open=False):
-                                        components = create_section_components(PROMPTS[prompt_key])
-                                        all_components[prompt_key] = components
+                                    # Create invisible container for output components
+                                    with gr.Group(visible=False) as output_group:
+                                        # Use create_dynamic_section_components to create the components
+                                        dynamic_components = create_dynamic_section_components(PROMPTS[prompt_key])
+                                        
+                                        # Add the group to the components dictionary
+                                        dynamic_components[f"{prompt_key}_group"] = output_group
+                                        
+                                        # Store all components
+                                        all_components[prompt_key] = dynamic_components
 
                 with gr.Column(scale=1):
                     with gr.Row():
@@ -289,20 +287,41 @@ def create_quotation_generator_section():
                         with gr.Column(scale=1):
                             page_upload_drive_btn = gr.Button("📁 Upload to Google Drive")
                             page_upload_notion_btn = gr.Button("📝 Upload to Notion")
-                            
-    with gr.Tab(label="Guidelines"):
-        gr.Markdown("### 🗒️ Note : There are 3 main steps. Each step has sub-steps.")
-        for notes in [
-            "**Step 1**: Generate General PRD, Plan Test Components, Development Components",
-            "**Step 2**: Generate Mandays Estimates & Cost Summary (General & MVP)",
-            "**Step 3**: Generate Final Documentation (MVP PRD , BD SOW , Tech SOW)"
-        ]:
-            gr.Markdown(notes)
 
+    # Add system prompts tab
+    with gr.Tab(label="System Prompts"):
+        gr.Markdown("## System Prompts")
+        gr.Markdown("Edit the system prompts below to customize the generation process.")
+        
+        # Add all prompt editors here
+        for prompt_key, prompt_config in PROMPTS.items():
+            # Check if prompt_config has ui attribute and it's not None
+            if prompt_config.ui is not None:
+                editor_key = next((k for k in prompt_config.ui.keys() if k.endswith('_prompt_editor')), None)
+                if editor_key:
+                    with gr.Accordion(f"{prompt_config.description}", open=False):
+                        components = create_prompt_editor_components(prompt_config)
+                        # Add editor components to all_components
+                        if prompt_key in all_components:
+                            all_components[prompt_key].update(components)
+                        else:
+                            all_components[prompt_key] = components
+
+    # Setup event handlers
+    setup_all_handlers(
+        step_buttons,
+        all_components,
+        page_progress_update,
+        quotation_cost,
+        page_upload_drive_btn,
+        page_upload_notion_btn,
+        page_recalc_btn,
+        project_name
+    )
 
-        return (all_components, step_buttons, 
-                page_progress_update, page_upload_drive_btn, page_upload_notion_btn, 
-                quotation_cost, page_recalc_btn, page_notes_box, page_save_quotation_btn , project_name)
+    return (all_components, step_buttons, 
+            page_progress_update, page_upload_drive_btn, page_upload_notion_btn, 
+            quotation_cost, page_recalc_btn, page_notes_box, page_save_quotation_btn, project_name)
 
 def update_display_mode(mode: str, text_content: str) -> tuple:
     return (
@@ -314,8 +333,8 @@ def update_display_mode(mode: str, text_content: str) -> tuple:
 with open("page_main.css", "r") as file:
     custom_css = file.read()
 
-with gr.Blocks(title="Page Quotation Chatbot (with SOW)", css=custom_css) as page_interface:
-    gr.Markdown("# Page Quotation Chatbot with SOW")
+with gr.Blocks(title="Quotation Chatbot (with SOW)", css=custom_css) as page_interface:
+    gr.Markdown("# Quotation Chatbot with SOW")
     
     all_components = {}
     
@@ -337,7 +356,7 @@ with gr.Blocks(title="Page Quotation Chatbot (with SOW)", css=custom_css) as pag
                 
                 for prompt_key, prompt_config in chatbot_prompts.items():
                     with gr.Accordion(prompt_config.description, open=False):
-                        components = create_section_components(prompt_config)
+                        components = create_prompt_editor_components(prompt_config)
                         chatbot_editors[prompt_key] = components
                         
         with gr.Row():

common_functions_v4.py

@@ -13,7 +13,7 @@ import os
 from dotenv import load_dotenv
 from langtrace_python_sdk import langtrace
 from state import state 
-from page_prompts_config import *
+from prompt_configs import *
 
 no_active_session = "**Current Session**:None"
 
@@ -23,11 +23,7 @@ if api_key is None:
     raise ValueError("Environment variable 'LANGTRACE_API_KEY' is not set. Please set it in your .env file.")
 langtrace.init(api_key=api_key)
 
-#This function is not being used 
-def check_session_exists():
-    """Check if a valid session exists"""
-    return state.quotation_project.session_id is not None
-
+#TODO: Since now we are merging both page and engage , we have to pull the project type in order to load the correct project
 def get_db_connection():
     """Establishes and returns a new database connection."""
     db_params = {

engage_prompts_config.py

@@ -1,1125 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-from typing import List, Dict, Any, Optional
-
-
-class ModelType(Enum):
-    O1_MINI = "o1-mini"
-    O4_MINI = "gpt-4o-mini"
-
-class UIComponentType(Enum):
-    TEXTBOX = "textbox"
-    MARKDOWN = "markdown"
-    DATAFRAME = "dataframe"
-
-@dataclass
-class UIConfig:
-    component_type: UIComponentType
-    label: str
-    default_value: Any = None
-    visible: Optional[bool] = True
-    interactive: Optional[bool] = True
-    lines: Optional[int] = None
-    description: str = ""
-    show_copy_button: Optional[bool] = False
-    elem_classes: Optional[List[str]] = None
-
-@dataclass
-class PromptConfig:
-    prompt: str
-    inputs: List[str]
-    outputs: List[str]
-    model: ModelType
-    description: str = ""
-    step: Optional[str] = None
-    sub_step: Optional[str] = None
-    ui: Dict[str, UIConfig] = None
-
-#################################################################################################################################################
-
-PROMPTS = {
-    "client_initial_question": PromptConfig(
-        prompt=
-        """
-        # Client Information Gathering Questions
-        
-        ### Company Background and Industry
-        1. Can you provide some background about your company?
-        2. Which industry do you operate in, and what is your company's niche or specialization?
-        3. Who are your primary customers?
-        4. What are the main objectives you want to achieve?
-        5. What key features or functionalities do you need?
-        
-        ### Current Challenges
-        6. What are the biggest challenges your firm is currently facing?
-        7. Can you describe your current processes?
-        
-        ### Workflow and System Impact
-        8. How will this solution benefit your firm as a whole?
-        
-        ### Existing Workflow or System
-        9. Can you describe your current workflow or system?
-        
-        ### Pain Point Identification
-        10. Where is your current system falling short or causing delays?
-        11. Are there any parts of the process that are particularly time-consuming/ prone to error?
-        """,
-        inputs=[],
-        outputs=[],
-        model=ModelType.O1_MINI,
-        description="Initial Client Questions",
-        step="Chatbot Prompt Editors",
-        ui={
-            "client_initial_question_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Initial Questions Prompt",
-                interactive=True,
-                lines=20
-            )
-        }
-    ),
-
-    "generate_client_follow_up": PromptConfig(
-        prompt=
-        """
-        Based on the initial list of questions and the client's provided answers, generate **insightful and targeted follow-up questions** that will help deepen my understanding of the following critical aspects:
-        
-        1. **Client Overview**
-        **Objective:** ask relevant questions that will directly contribute to better project requirements gathering. (ie: department team that the project is meant for ..etc)
-        
-        2. **Project Vision and Value**
-        **Objective:** Clarify the intended impact of the project on the client's business. Understand how it will improve their processes, solve key challenges, and deliver measurable benefits.
-        **Focus:** Investigate specific outcomes, immediate expected goals, and how success will be defined.
-        
-        3. **Existing System or Workflow Description**
-        **Objective:** Delve deeper into the client's current tools, workflows, and processes to uncover pain points, integration requirements, and opportunities for optimization.
-        **Focus:** Identify inefficiencies, technical limitations, or gaps that the project will address.
-        
-        4. **Budget and Resource Constraints**
-        **Objective:** Clearly define any limitations or constraints—financial, resource-based, or time-related—that could impact project success.
-        **Focus:** Understand the flexibility of the budget, timeline expectations, and resource availability.
-        
-        Instructions:
-        Each question should:
-        Build on provided client information
-        Non repetitive, and unique. Avoid asking similar questions.
-        Include realistic sample answers relevant to the client's context
-        Focus on gathering quantifiable or specific information
-        
-        
-        Output top 10 questions in the following format:
-        <question>(sample answers)
-        Just return the text and NOTHING else. Do not overexplain, omit code guards.
-        """,
-        inputs=["project_detail"],
-        outputs=["follow_up_questions"],
-        model=ModelType.O1_MINI,
-        description="Generate follow-up questions with sample answers",
-        step="Chatbot Prompt Editors",
-        ui={
-            "client_follow_up_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Client Follow-up Questions Prompt",
-                lines=20,
-                interactive=True,
-            )
-        }
-    ),
-    
-    "generate_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. 
-        
-        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.
-        
-        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: "Why do call centers become overloaded during month-end? Are there specific processes causing bottlenecks?"
-        Highlight systemic issues where patterns emerge (e.g., manual processes across multiple challenges).
-        
-        # Output Format:
-        # <index><question>(sample answers)
-        
-        Just return the generated list of follow up questions as string and nothing else.
-        """,
-        inputs=["project_detail"],
-        outputs=["generated_follow_up_questions"],
-        model=ModelType.O1_MINI,
-        description="Generate detailed follow up questions with sample answers",
-        step="Chatbot Prompt Editors",
-        ui={
-            "follow_up_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Folow-up Questions Prompt",
-                lines=20,
-                interactive=True
-            )
-        }
-    ),
-    
-    "question_generator": PromptConfig(
-        prompt=
-        """
-        You are a chatbot project manager responsible for gathering detailed requirements in order to generate an accurate and comprehensive quotation for a client's chatbot project. 
-        Your task is to ask good follow up questions based on what you already know
-        Consider the following inputs:
-        
-        1. **Requirements Rubric:** Use this as a baseline list of initial questions of the chatbot 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.
-        """,
-        inputs=["project_detail", "requirements_rubric"],
-        outputs=["generated_questions"],
-        model=ModelType.O1_MINI,
-        description="Generate detailed questions with sample answers",
-        step="Chatbot Prompt Editors",
-        ui={
-            "question_generator_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Question Generator Prompt",
-                lines=20,
-                interactive=True,
-            )
-        }
-    ),
-    
-    "generate_prd": PromptConfig(
-        prompt=
-        """
-        Rewrite this for clarity while keeping all specific details, metrics, and constraints.
-        Please take note of the time constraint to build the MVP.
-        Do not include context or assumptions beyond the input provided.
-        Do not also exclude any input provided.
-        Structure the document to ensure clarity and logical flow.
-        Make sure to make the title "Project Requirements".
-        """,
-        inputs=["project_detail"],
-        outputs=["generated_prd"],
-        model=ModelType.O1_MINI,
-        description="Step 1.1 : Generate Project Requirements Document (PRD)",
-        step="Step 1 : Scope & Components",
-        ui={
-            "requirement_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Requirements(PRD) System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_prd_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Requirements(PRD) Output",
-                lines=20,
-                visible=True
-            ),
-            "generated_prd_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="Requirements(PRD) Output",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-    
-    "generate_intent_list": PromptConfig(
-        prompt=
-        """
-        You are an solution architect and project manager with 20+ years of experience in building chatbots and AI-powered systems.
-        Your task is to analyze the provided project requirement document and help me understand the complexity of the project by defining ALL possible intents and workflows for each requirement.
-        Additionally, anticipate and suggest realistic, real-life intents that might have been overlooked by the client but are critical for a robust and user-friendly chatbot. You can reference **how other chatbots in the same industry are functioning** and suggest intents that are commonly provided by competitors but may not have been explicitly mentioned by the client. List down these suggestion in one seperate table.
-        
-        Instruction:
-        1. **Break Down Requirements**: Identify all the client requirements from the document.
-        2. **Define ALL Possible Intents and Workflows**: For each requirement, list ALL possible intents and their corresponding workflows.  - Use "→" to represent the flow between steps.
-        - Provide your analysis in a clear, highly readable and structured table format. The intents to consider are:
-        - Simple
-        - Complex
-        - Multi-Step
-        - Single-Step
-        - Fallback.Focus on business-centric fallback (e.g., "Order Management Fallback" should address specific order-related issues like invalid SKU, payment failure, or inventory unavailability)
-        - Others (if applicable)
-        
-        Output Format:
-        Present the analysis in a tabular format with the following structure:
-        - Each requirement as the title of a separate table.
-        - **Columns**:
-        - Intent Type (e.g., Simple, Complex, Multi-Step, etc.)
-        - Intent (e.g., Order Status Inquiry, Track Order Progress, etc.)
-        - Workflow (describe the technical/logical steps using "→" and numbered steps, e.g., "1. Extract user input → 2. Query database → 3. Return result").
-        """,
-        inputs=["generated_prd"],
-        outputs=["generated_intent_list"],
-        model=ModelType.O1_MINI,
-        description="Step 1.2 : Generate Intent List",
-        step="Step 1 : Scope & Components",
-        ui={
-            "intent_list_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Intent List System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_intent_list_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Intent List Output",
-                lines=20,
-                visible=True
-            ),
-            "generated_intent_list_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="Intent List Output",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-
-    "generate_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="Step 1.3 : 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_dev_components": PromptConfig(
-        prompt=
-        """
-        **Role**: 
-        You are a technical project manager and software architect specializing in chatbot development.
-        Your task is to create a granular "Development Component List" by extracting components from the **Project Requirement Document (PRD)** and the **Chatbot Intent List (CIL)**.
-        The output should align with the **project's specific goals** and focus on **technical implementation**. 
-    
-        ### **Objectives**: 
-        1. **Complements the CIL**: Ensure the components directly support the intents and workflows defined in the CIL.
-        2. **Aligns with the PRD**: Incorporate project-specific goals, business logic, and technical requirements from the PRD.
-        3. **Focus on Technical Implementation**: Provide actionable development tasks and deliverables.
-        4. **Project-Specific**: Avoid generic components; extract details directly from the PRD and CIL.
-        5. **Granular and Readable**: Maintain a balance between granularity and readability for actionable outputs.
-    
-        **Key Focus**: 
-        - Translate the **intents, workflows, fallbacks, and unhappy paths** from the CIL into **specific development deliverables** or tasks.
-        - Ensure that the deliverables are **actionable** and **context-aware**, aligning with the project's technical stack and business requirements.
-    
-        ### **Inputs**: 
-        1. **PRD**: Contains functional, non-functional, technical, and compliance requirements for the chatbot project. 
-        2. **CIL**: Lists intents the chatbot will handle, including **fallbacks** and **unhappy paths** with their corresponding workflows. 
-    
-        ---
-    
-        ### **Process**: 
-        1. **Read and Analyze the PRD and CIL**: 
-           - Carefully review the PRD to understand the **project's specific goals, business logic, and technical requirements**. 
-           - Review the CIL to identify the intents, workflows, fallbacks, and unhappy paths the chatbot will handle. 
-    
-        2. **Extract Granular Components**:  
-           - Identify *ALL components* in the PRD and the CIL.
-           - Components should directly reference functionalities or deliverables related to the project.
-           - Identify key business logic.
-           - Prioritize components that provide high business value, such as core functionality. 
-           - Organize components into logical categories. Avoid Testing, Support and Maintenance, Documentation and Training components.  
-    
-        3. **Identify Unhappy Paths and Fallbacks**:  
-           - For each intent including the suggested or additional intents, identify unhappy paths or fallbacks (e.g., errors, exceptions, or edge cases) provided in the CIL. Define **specific development deliverables** or tasks. Examples include:
-             - **Order Creation**: Implement SKU validation logic and inventory availability checks.
-             - **Payment Processing**: Integrate payment retry mechanisms and notify users of payment status.
-             - **Document Extraction**: Add field validation logic and manual upload options for failed extractions.
-             - **Input Validation**: Implement file size and type checks, and provide fallback instructions for unsupported inputs.
-           - Ensure that the deliverables are **actionable** and **context-aware**.
-           
-        ---
-    
-        ### **Tech Stack**: 
-        - **Backend**: FastAPI, Python 
-        - **Chatbot Tools**: Chatbot Builder , COZE , Yellow.ai
-        - **Infrastructure**: AWS, PostgreSQL, Redis, Docker, Alembic 
-    
-        ---
-    
-        ### **Output**: 
-        - Compile a list of components from the PRD and CIL. 
-        - Use a clear, tabular format with **project-specific context** for each component: 
-        - Avoid using "Handle" for the Subcomponent naming.
-    
-        | **Component**       | **Subcomponent**       | **Deliverables**               | 
-        |---------------------|------------------------|--------------------------------| 
-        | **<Component 1>**   | **<Subcomponent 1>**   | 1. <Deliverable 1> <br> 2. <Deliverable 2> <br> 3. <Deliverable 3> | 
-    
-        Return the final tables and nothing else. Do not provide a summary at the end.
-        """,
-        inputs=["generated_prd" , "generated_intent_list"],
-        outputs=["generated_dev_components"],
-        model=ModelType.O1_MINI,
-        description="Step 1.4 : Generate development components",
-        step="Step 1 : Scope & Components",
-        ui={
-            "dev_component_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Development System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_dev_components_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Development Components Output",
-                lines=20,
-                visible=True
-            ),
-            "generated_dev_components_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="Developemnt Components Output",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-    
-    "reformat_dev_components": PromptConfig(
-        prompt=
-        """
-        **Role**:  
-        You are a technical project manager and software architect responsible for ensuring consistent naming conventions in chatbot development. Your task is to standardize the naming of common chatbot components and subcomponents while preserving all existing components and subcomponents, including unique, domain-specific components.
-
-        ### **Process**:  
-        1. **Analyze the Development Component List (DCL)**:  
-           - Identify components and subcomponents that are common across chatbot projects (e.g., "Chatbot Engine" vs. "Chatbot Interface").
-           - Identify domain-specific components that should remain unchanged.
-           - Ensure that technical terminology and categorization are consistent across component , particularly for components of similar concepts to maintain uniformity.
-
-        2. **Standardize Common Chatbot Components**:  
-           - Cross-check common components against a standardized reference list (see below).
-           - Rename only the common chatbot components to their standardized equivalent while keeping the intended meaning intact.
-           - Ensure all subcomponents are retained and placed under the correct standardized component.
-
-        3. **Preserve All Existing Components and Subcomponents**:  
-           - Ensure that no components or subcomponents are removed during standardization
-           - If a component is highly specific to a particular use case, do not modify it
-           - Retain any unique features that are tailored to the project
-           - Verify that each component has appropriate subcomponents and deliverables
-
-        ### **Standardized Naming Conventions (for Common Chatbot Components)**:
-        | **Standard Component**       | **Common Subcomponents**       |
-        |------------------------------|--------------------------------|
-        | Core Chatbot Engine          | Intent Recognition, NER, Context Management, Dialog Flow, Response Generation, Multi-turn Handling |
-        | LLM Processing Pipeline      | Text Preprocessing, Entity Extraction |
-        | Integration Layer            | API Gateway, CRM/ERP Integration, Knowledge Base Integration, Third-party Services |
-        | Data Management              | ETL Pipelines, Database Operations, Data Versioning, Cache Management |
-        | Security and Compliance      | Authentication, Authorization, Data Encryption, Audit Logging, GDPR/PDPA Compliance |
-        | Infrastructure               | AWS/Cloud Setup, Docker Containerization, CI/CD Pipeline, Environment Management |
-        | Error Handling               | Error Logging, Exception Management, Fallback Responses, Escalation Workflows |
-        | User Management              | User Authentication, Profile Management, Session Handling, Role-based Access |
-        | Monitoring & Analytics       | Performance Metrics, Usage Analytics, Error Tracking, Real-time Dashboards |
-        | Feedback & Learning          | User Feedback Collection, Model Performance Tracking, A/B Testing, Continuous Learning |
-        | Conversation Management      | Context Retention, Topic Switching, Language Support, Flow Control |
-        | Channel Management           | Web Integration, Mobile Support, Social Media Platforms |
-        | AI/ML Components             | LLM Integration, RAG Implementation, Fine-tuning Pipeline, Vector Store Management |
-        | Business Logic Layer         | Custom Rules Engine, Workflow Automation, Business Process Integration |
-        | Knowledge Management         | Content Management, FAQ Updates, Knowledge Graph, Document Processing |
-        | Human Handoff                | Agent Routing, Queue Management, Conversation History Transfer, Live Chat Support |
-        | Performance & Scaling        | Load Balancing, Auto-scaling, Performance Optimization, Resource Management |
-        | Development Tools            | Testing Framework, Debugging Tools, Development Environment, Documentation |
-
-        ### **Output**:  
-        - Return the Updated Component List in a clear, structured format.
-        - Maintain the tabular format while applying consistent naming conventions.
-        - Each component should be distinct and well-defined.
-        - No repeated components or overlapping functionality.
-        - Ensure that all components and subcomponents are included in the output.
-        - Provide only the corrected table and nothing else.
-        """,
-        inputs=["generated_dev_components"],
-        outputs=["reformatted_dev_components"],
-        model=ModelType.O1_MINI,
-        description="Step 1.5 : Reformat development components",
-        step="Step 1 : Scope & Components",
-        ui={
-            "reformatted_dev_components_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Reformatted Development Components",
-                lines=20, 
-                interactive=True
-            ),
-            "reformatted_dev_components_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Reformatted Development Components Output",
-                lines=20,
-                visible=True
-            ),
-            "reformatted_dev_components_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="Reformatted Development Components Markdown Output",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-    
-    "generate_intents_csv": PromptConfig(
-        prompt=
-        """
-        You will be provided with an intent list. Your task is to convert the entire list into a CSV string, ensuring that all rows from the list are included without omission. The CSV should contain the following columns: "intent_type", "intent", and "workflow". Follow these rules:
-        
-        Enclose all text values, including the column headers, in double quotes ("").
-        Retain numeric values as-is, without any quotes.
-        Ensure the CSV string is formatted correctly, with commas separating the values and each row represented on a new line.
-        Your response must include every row and correctly reflect the structure and content of the intent list. Just return the CSV text and nothing else. Omit any code guards ```.
-        """,
-        inputs=["generated_intent_list"],
-        outputs=["generated_intents_csv"],
-        model=ModelType.O1_MINI,
-        description="Step 2.1 : Generate Intent CSV",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.1 : Generate Mandays",
-        ui={
-            "intents_csv_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Intent CSV System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_intents_csv_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="Generated Intents CSV",
-                interactive=True,
-                visible=True
-            )
-        }
-    ),
-
-    "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 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
-        
-        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.
-        """,
-        inputs=["generated_plan_test_components"],
-        outputs=["generated_plan_test_mandays"],
-        model=ModelType.O1_MINI,
-        description="Step 2.1 : Generate Plan Test 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_dev_mandays": PromptConfig(
-        prompt=
-        """
-        You are an experienced project manager tasked to create a detailed task breakdown for a project based on 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.
-        - Subcomponent: The subcategory or module within the 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 and the development component list to identify all components, subcomponents, tasks and subtasks.
-        
-        2. Manday Estimation:
-        For each subcomponent, estimate the manday based on the effort required for a single person to complete it,, ensuring it falls between 0.5 and 7 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"
-        Make sure you encapsulate all TEXT column in "", and keep numeric columns as is.
-        Just return the csv text and NOTHING else, omit the ``` code guards.
-        """,
-        inputs=["reformatted_dev_components"],
-        outputs=["generated_dev_mandays"],
-        model=ModelType.O1_MINI,
-        description="Step 2.1 : Generate Development Mandays",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.1 : Generate Mandays",
-        ui={
-            "dev_mandays_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Dev Mandays System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_dev_mandays_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="Dev Mandays",
-                interactive=True,
-                visible=True
-            )
-        }
-    ),
-    
-    "generate_MVP_prd": PromptConfig(
-        prompt=
-        """
-        Generate a comprehensive and structured Project Requirement Document (PRD) for a Minimum Viable Product (MVP) using the following inputs:
-        1. **General PRD Guidelines**: Use the provided general PRD as a framework for structure, tone, and level of detail. This includes sections like Introduction, Scope, Functional Requirements, Non-Functional Requirements, Technical Architecture, Workflow, Testing, Deployment, and Appendices.
-        2. **MVP Components**: Incorporate the specific MVP components & intents, including their descriptions, mandays estimates, and functionalities, into the relevant sections of the PRD. Ensure all details are accurately reflected.
-        
-        Follow these instructions:
-        - Retain ALL specific details, metrics, and constraints from both the general PRD and MVP components.
-        - Pay special attention to the time constraint for building the MVP, as outlined in the inputs.
-        - Do not add any context or assumptions beyond the provided inputs.
-        - Do not exclude any details from the inputs.
-        - Structure the document to ensure clarity, logical flow, and readability and structure tabular format if necessary.
-        - Use the title "Project Requirements" for the document.
-        
-        The output should be a well-organized PRD that combines the general PRD guidelines with the specific MVP components, ensuring alignment with the project's goals and constraints.
-        """,
-        inputs=["generated_prd" , "mvp_components"],
-        outputs=["generated_mvp_prd"],
-        model=ModelType.O1_MINI,
-        description="Step 3.1 : Generate MVP PRD",
-        step="Step 3 : Final Documentation",
-        ui={
-            "mvp_prd_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="MVP PRD System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_mvp_prd_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="MVP PRD Output",
-                lines=20,
-                visible=True
-            ),
-            "generated_mvp_prd_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="MVP PRD Output",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-
-    "generate_BD_SOW": PromptConfig(
-        prompt=
-        """
-        As an project manager with 20+ years of experience, you are tasked to create a detailed Scope of Work (SOW) document. Analyze the provided project component list and scope document to generate the following sections. Follow the guidelines below to ensure a professional, structured, and client-ready output:
-        
-        ### **Scope of Work (SOW)**
-        
-        #### **1. Project Background**
-        - Provide a brief overview of the project, including the context, problem statement, and why the project is being initiated.
-        - Break down key challenges (in bullet point) the company currently facing, quantifying the impacts where possible (e.g., lost revenue, downtime).
-        - Close this section with industry trends or other relevant background information, emphasizing risks of inaction leading to the project, in 2-3 sentences.
-        
-        #### **2. Project Objective**
-        - Clearly define the project's primary goals and what constitutes success, using the following structure:
-        - Goals: List specific, measurable goals (e.g., reduce processing time by 20%).
-        - Outcomes: Describe tangible deliverables and metrics for success.
-        
-        #### **3. Project Buyers & Stakeholders**
-        - List key stakeholders involved in the project, e.g. buyers, end-users, and decision-makers.
-        - Identify their name and roles in the project, using a table.
-        
-        #### **4. System Flow**
-        - Provide description of how the system components interact, describing what each module does and how it works.
-        - Use one of the following:
-        - Visual Representation: Diagram illustrating workflows or data flows between modules.
-        - Textual Description: Detailed explanation of the processes and transitions
-        - Use bullet point, ensure simplicity and avoid overly technical language.
-        
-        #### **5. Modules and Functional Requirements Breakdown**
-        - LEAVE THIS BLANK
-        
-        #### **6. Acceptance Criteria**
-        - Define conditions to be met, including specific, measurable criteria for project completion:
-        - Link each deliverable/module to its validation or testing process (e.g., UAT).
-        - Table format with the following column:
-        - Deliverable (e.g. Field Matching Automation module)
-        - Criteria, starting with "able to" (e.g. able to extract, match, and change the case status accordingly)
-        
-        #### **7. Assumptions and Pre-requisites**
-        - List all planning-phase assumptions and pre-requisites, grouped into:
-        - Assumptions: Detailed, scenario-based assumptions that the project relies on. Each assumption should:
-        - Reference specific stakeholders (e.g., PWT staff, Mindhive).
-        - Describe specific conditions or expectations (e.g., document quality, workflow stability).
-        - Be written in clear, concise language.
-        - Pre-requisites or dependencies: Conditions that must be met before the project can proceed. Each pre-requisite should:
-        - Be specific and actionable.
-        - Reference who is responsible and what needs to be done.
-        
-        #### **8. Proposed Timeline**
-        - Provide a project timeline, including:
-        - Milestone
-        - Expected Date/Duration
-        - Outcome/Deliverable
-        - Use a Gantt chart or table to visualize the timeline.
-        - Ensure the output are clean, organized, and easy to read.
-        
-        #### **9. Commercial**
-        Summarize the project's commercial details in the following subsections:
-        - Development Fee: Create a table summarizing the costs for development, including the product, technical work supporting, or other additional services provided
-        - Subscription Fee: If applicable, create a table summarizing subscription fees for system usage.
-        - Payment Terms: Include a text description of payment terms:
-        - Milestones: Specify at which stages payments are due
-        - Invoicing: Define invoicing intervals (e.g., monthly, quarterly) and payment deadlines
-        - Other Terms: Mention late payment fees or additional terms, if applicable
-        - Output Format for tables: {Service}, {Fee} (leave amount blank)
-        
-        #### **10. Sign-Off**
-        - Create a professional and formal Sign-Off section  to acknowledge and approve the SOW.
-        - Include an statement to clearly communicate that both parties have reviewed and agreed to the SOW.
-        - Provide placeholder for each party (Company):
-        - Signature
-        - Name
-        - Position
-        - Date
-        
-        #### **Guidelines**
-        - Use bullet points for clarity.
-        - Keep descriptions concise and client-friendly; avoid technical jargon unless necessary.
-        - Maintain structured sections and tables for readability.
-        
-        Expected output should be professional, well-structured, and designed to help clients and stakeholders clearly understand the project scope. I'm going to tip you for a better outcome!
-        """,
-        inputs=[
-            "generated_prd",
-            "generated_plan_test_components",
-            "reformatted_dev_components",
-            "generated_intent_list",
-            "quotation_cost" 
-        ],
-        outputs=["generated_BD_SOW"],
-        model=ModelType.O1_MINI,
-        description="Step 3.2 : Generate Business Development SOW",
-        step="Step 3 : Final Documentation",
-        ui={
-            "BD_SOW_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="BD SOW Generator Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_BD_SOW_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="BD SOW",
-                lines=20,
-                visible=True
-            ),
-            "generated_BD_SOW_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="BD SOW",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-
-    "generate_Tech_SOW": PromptConfig(
-        prompt=
-        """
-        As an experienced project manager with over 20 years of expertise, you are tasked to create a detailed Scope of Work (SOW) document in JSON format. The JSON output should contain markdown-formatted strings as values for each section of the SOW. Analyze the provided project component list and scope document to generate the following sections:
-        
-        ### **Scope of Work (SOW)**
-        
-        #### **1. Scope Summary**
-        - Provide a concise, high-level overview of the project scope. Divide it into three subsections:
-        - In Scope:
-        - List all deliverables, functionalities, and modules included in the project.
-        - Be specific about what will be developed, implemented, or delivered.
-        - Include MVP components (e.g., basic features, functionality, UI, document processing).
-        - Assumptions:
-        - Highlight key project-specific assumptions that the project relies on.
-        - Dependencies:
-        - List all internal and external dependencies required for the project's success.
-        - Include any third-party integrations, resources, or timelines that the project depends on.
-        
-        #### **2. Modules and Functional Requirements Breakdown**
-        - Break down the project into modules or components.
-        - Prsent the details in a succinct and client-friendly table with the following column:
-        - Module
-        ii. Functionalities/Features
-        iii. Notes for any special considerations or constraints (e.g., 'Supports files up to 100MB').
-        - Use clear, concise, non-technical language. (e.g., 'Drag-and-drop support for PDFs, Excel, CSV; progress indicators'). Avoid excessive detail.
-        - Include MVP components as part of the breakdown and provide clear functionalities related to those (e.g., basic document upload, UI features, data processing).
-        
-        #### **3. Out of Scope**
-        - Explicitly define what is excluded from the project's scope. This may include any functionalities, tasks, or deliverables.
-        - Ensure clarity to prevent future misunderstandings.
-        
-        #### **4. System Flow**
-        - Provide a detailed, step-by-step description of how the system components interact.
-        - For each component or module:
-        - Describe what it does and how it works, including both success and unsuccessful scenarios
-        - Explain how it interacts with other components
-        - Include MVP-related components in the system flow, describing their function and interaction within the MVP's framework.
-        
-        Output Requirements:
-        Just return the json object and nothing else, omit code guards ```, where each key represents a section of the SOW, and the value is a markdown-formatted string for that section.
-        Use clear, concise, and client-friendly language. Avoid excessive technical jargon unless necessary.
-        Example JSON Output:
-        {
-        "scope_summary": <markdown content>,
-        "modules_and_functional_requirements": <markdown content>,
-        "out_of_scope": <markdown content>,
-        "system_flow": <markdown content>
-        }
-        """,
-        inputs=["generated_plan_test_components","reformatted_dev_components","generated_intent_list","mvp_components"],
-        outputs=["generated_Tech_SOW"],
-        model=ModelType.O1_MINI,
-        description="Step 3.3 : Generate Technical SOW",
-        step="Step 3 : Final Documentation",
-        ui={
-            "Tech_SOW_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Technical SOW Generator Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_Tech_SOW_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Technical SOW",
-                lines=20,
-                visible=True
-            ),
-            "generated_Tech_SOW_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="Technical SOW",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-    
-    "analyze_planning_testing_mandays": PromptConfig(
-        prompt=
-        """
-        You are an experienced project manager tasked with analyzing the provided planning and testing mandays estimates. Your goal is to identify the highest priority components that must be completed to build the MVP. Focus on components that deliver **immediate value to users** and are **critical for the core functionality** of the product.
-        
-        Objective:
-        Identify the highest priority planning and testing components that are critical for the MVP's core functionality and deliver immediate value to the business. Exclude all non-critical components that do not directly contribute to the MVP's primary functionality.
-        
-        Key Guidelines:
-        - Focus on Core Functionality: Only include components that are essential for the MVP to function and deliver immediate value to users.
-        - Exclude Non-Critical Components: Do not include components related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is not absolutely necessary for the MVP.
-        - Prioritize Business Value: Ensure the selected components align with the business's core objectives and deliver measurable value.
-        - Minimalistic Approach: Focus on the least effort required to deliver the most value.
-        
-        Output Format Requirements:
-        - Provide a clear list of identified priority planning/testing components with a brief justification for each selection.
-        - Ensure the output is concise and actionable.
-        """,
-        inputs=["generated_plan_test_mandays"],
-        outputs=["identified_planning_testing_components"],
-        model=ModelType.O1_MINI,
-        description="Step 2.2 : MVP Plan_Test Analysis",
-        step='Step 2 : Mandays & Quotation',
-        sub_step="Step 2.2 : Analyze Components",
-        ui={
-            "mvp_planning_testing_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="MVP Plan_Test Analysis Prompt",
-                lines=20,
-                interactive=True
-            )
-        }
-    ),
-    
-    "analyze_development_mandays": PromptConfig(
-        prompt=
-        """
-        You are an experienced project manager tasked with analyzing the provided development mandays estimates. Your goal is to assign a priority level to each development component based on its importance to the MVP's core functionality and business value. Focus exclusively on components that deliver immediate value to users and are critical for the core functionality of the product.
-        
-        Key Guidelines:
-        - **Focus on Core Functionality:** Assign priority levels based on how essential each component is for the MVP to function and deliver immediate value to users.
-        - **Exclude Non-Critical Considerations:** Do not label components related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is **NOT** absolutely necessary for the MVP as "high" priority.
-        - **Prioritize Business Value:** Ensure the priority levels align with the business's core objectives and deliver measurable value.
-        - **Minimalistic Approach:** Focus on the least effort required to deliver the most value when assigning priority levels.
-        - **Assign Priority Levels:** Label each development component as "high," "medium," or "low" priority based on its importance to the MVP's core functionality and business value.
-        
-        Objective:
-        Assign a priority level ("high," "medium," or "low") to each development component, ensuring the output reflects the importance of each component to the MVP's core functionality and business value. Retain all original components in the list.
-        
-        Output Format Requirements:
-        - Provide a list of all development components with their assigned priority levels.
-        - Include a "Priority" column labeling each component as "high," "medium," or "low."
-        - Ensure the output is concise and actionable.
-        
-        Important Notes:
-        - If a component is not directly tied to the core functionality or can be deferred to a later phase, assign it a lower priority ("medium" or "low").
-        - Do not exclude any components from the list, even if they are low priority.
-        - Only assign "high" priority to components that are absolutely necessary for the MVP to function.
-        """,
-        inputs=["generated_dev_mandays"],
-        outputs=["identified_development_components"],
-        model=ModelType.O1_MINI,
-        description="Step 2.2 : MVP Development Analysis",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.2 : Analyze Components",
-        ui={
-            "mvp_development_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="MVP Development Analysis Prompt",
-                lines=20,
-                interactive=True
-            )
-        }
-    ),
-        
-    "analyze_mvp_intents": PromptConfig(
-        prompt=
-        """
-        You are an experienced project manager tasked with analyzing the provided intents mandays estimates. Your goal is to assign a priority level to each intents based on its importance to the MVP's core functionality and business value. Focus exclusively on intents that deliver immediate value to users and are critical for the core functionality of the product.
-        
-        Key Guidelines:
-        - **Focus on Core Functionality:** Assign priority levels based on how essential each intents is for the MVP to function and deliver immediate value to users.
-        - **Exclude Non-Critical Considerations:** Do not label intents related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is **NOT** absolutely necessary for the MVP as "high" priority.
-        - **Prioritize Business Value:** Ensure the priority levels align with the business's core objectives and deliver measurable value.
-        - **Minimalistic Approach:** Focus on the least effort required to deliver the most value when assigning priority levels.
-        - **Assign Priority Levels:** Label each development intents as "high," "medium," or "low" priority based on its importance to the MVP's core functionality and business value.
-        
-        Objective:
-        Assign a priority level ("high," "medium," or "low") to each development intents , ensuring the output reflects the importance to the MVP's core functionality and business value. Retain all original components in the list.
-        
-        Important Notes:
-        - If a component is not directly tied to the core functionality or can be deferred to a later phase, assign it a lower priority ("medium" or "low").
-        - Do not exclude any intents rom the list, even if they are low priority.
-        - Only assign "high" priority to intents that are absolutely necessary for the MVP to function.
-        
-        Output Format Requirements:
-        Convert the entire list into a CSV string, ensuring that all rows from the list are included without omission. The CSV should contain the following columns: "intent_type", "intent", and "workflow". Follow these rules:
-        
-        Enclose all text values, including the column headers, in double quotes ("").
-        Retain numeric values as-is, without any quotes.
-        Ensure the CSV string is formatted correctly, with commas separating the values and each row represented on a new line.
-        Your response must include every row and correctly reflect the structure and content of the intent list. Just return the CSV text and nothing else. Omit any code guards ```.
-        """,
-        inputs=["generated_intent_list"],
-        outputs=["identified_mvp_intents"],
-        model=ModelType.O1_MINI,
-        description="Step 2.2 : MVP Intent Analysis",
-        step='Step 2 : Mandays & Quotation',
-        sub_step="Step 2.2 : Analyze Components",
-        ui={
-            "mvp_intents_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="MVP Intent Analysis Prompt",
-                lines=20,
-                interactive=True
-            )
-        }
-    ),
-    
-    "recalculate_mandays": PromptConfig(
-        prompt=
-        """
-        Based on the identified priority components and the identified priority intent list from the previous analysis , your task is to recalculate the mandays estimates to ensure they fit within the time given (e.g., days or weeks) in building the MVP mentioned in the Project Requirement Document (PRD).
-        
-        Objective:
-        Read the entire PRD and identify the time constraint ; Recalculate the manday estimates for both development components and intents to ensure the total combined mandays fit within the MVP timeline specified in the Project Requirement Document (PRD). Adjust mandays while maintaining feasibility and ensuring core functionality delivery. Retain all components and intents in the list, even if their mandays are set to 0.
-        
-        Key Guidelines:
-        1. Total Combined Mandays Constraint:
-        The combined total mandays for development components and intents must not exceed MVP timeline.
-        Ensure the total is calculated as:
-        Total Combined Mandays = Development Components Mandays + Intents Mandays ≤ MVP timeline.
-        Convert Time Estimates:
-        Convert all time estimates into raw mandays:
-        - 1 week = 7 mandays
-        - 1 month = 28-31 mandays
-        - If input is in days, use as is.
-        - If input is a range (e.g., 1-2 weeks), use the average (1.5 weeks = 7.5 mandays).
-        2. Preserve All Components and Intents:
-        3. Do not remove any components or intents from the list, even if their mandays are set to 0.
-        4. Retain all planning and testing components but set their mandays to 0.
-        5. Adjust Mandays Based on Priority:
-        - For high priority, allocate the majority of mandays to ensure critical functionalities are minimally viable. Significant reductions may be necessary for non-core features (e.g., authentication, security).
-        - For medium priority, allocate minimal mandays or set them to 0, as these can be deferred without impacting core functionalities.
-        - For low priority, set mandays to 0, as these are not essential for the MVP.
-        6. Iterative Adjustment:
-        - If the total combined mandays still exceed the MVP timeline after the first adjustment, further reduce mandays for both high and medium priority components and intents until the total fits within the timeline.
-        - Set mandays to 0 for non-essential components and intents if necessary, but do not remove them from the list.
-        7. Strict Calculation for Intents:
-        Properly calculate the total mandays for development components and MVP intents. Ensure the total combined mandays for both development components and MVP intents DO NOT exceed the MVP timeline.
-        8. Justify Adjustments:
-        - Provide a brief explanation for any adjustments made to the mandays, ensuring they align with the timeline and maintain the MVP's core functionality.
-        
-        Output Format Requirements:
-        - Provide a revised list of development components and intents with updated mandays estimates.
-        - Include the "Priority" column for reference.
-        - Include the total mandays for the revised plan and confirm whether it fits within the MVP timeline.
-        - Retain all components and intents in the list, even if their mandays are set to 0.
-        - Ensure the output is concise and actionable.
-        
-        Important Notes:
-        - If the total mandays still exceed the timeline after adjustments, prioritize further reductions in medium priority components and intents while keeping high priority components as intact as possible.
-        - Do not remove any components or intents from the list, even if their mandays are reduced to 0.
-        """,
-        inputs=["identified_priority_components", "identified_mvp_intents" , "generated_prd"],
-        outputs=["revised_mandays_estimates"],
-        model=ModelType.O1_MINI,
-        description="Step 2.3 : MVP Mandays Recalculation Prompt",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.3 : Recalculate Mandays",
-        ui={
-            "mandays_recalculation_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="MVP Mandays Recalculation Prompt",
-                lines=20,
-                interactive=True
-            )
-        }
-    ),
-    
-    "generate_MVP_mandays": PromptConfig(
-        prompt=
-        """
-        Using the revised mandays estimates from the previous step, format the output into three clearly separated CSV sections: one for Planning/Testing Components, one for Development Components, and another for MVP Intents.
-        
-        Objective:
-        Structure the output to clearly delineate the three sections while maintaining the original column structure.
-        
-        Output Format Requirements:
-        - First Section - Planning & Testing Components:
-        component,mandays,description
-        "Requirements Analysis",0,"Critical user requirements and system specifications"
-        
-        - Second Section - Development Components:
-        component,subcomponent,mandays,description
-        "Backend","Core API Development",3,"Essential API endpoints for basic functionality"
-        
-        - Third Section - MVP Intents:
-        intent_type,intent,workflow,mandays
-        "Single-Step","Create New Order","1. User initiates order creation → 2. Extract order details from user input → 3. Save order to database → 4. Confirm creation to user",0.3
-        
-        Important:
-        - Each section must maintain its original column structure.
-        - Sections MUST be separated by the marker: "---SECTION BREAK---".
-        - Include ALL the components and intents.
-        - No empty rows or missing values.
-        - Text values must be in double quotes.
-        - Numbers must not be in quotes.
-        
-        Return only the CSV content with the section break, no additional text or explanations.
-        """,
-        inputs=["revised_mandays_estimates"],
-        outputs=["generated_MVP_mandays"],
-        model=ModelType.O1_MINI,
-        description="Step 2.3 : Generate MVP Mandays",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.3 : Recalculate Mandays",
-        ui={
-            "generated_MVP_mandays_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="MVP Mandays Formatting System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "mvp_plan_test_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="MVP Planning & Testing Components",
-                interactive=True,
-                visible=True
-            ),
-            "mvp_dev_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="MVP Development Components",
-                interactive=True,
-                visible=True
-            ),
-            "mvp_intents_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="MVP Intents",
-                interactive=True,
-                visible=True
-            )
-        }
-    ),
-}

event_handler.py

@@ -0,0 +1,107 @@
+from Project import *
+from google_drive import *
+from notion import upload_to_notion
+from state import state
+import gradio as gr
+import json
+from prompt_configs import PROMPTS
+import pandas as pd
+from io import StringIO
+
+def make_components_visible(progress_update):
+    """Make components visible before generating content"""
+    try:
+        # Create a list of updates to make components visible
+        updates = [progress_update.update(value="Starting generation...")]
+        
+        # Make all components visible first
+        for function_name, function_components in components.items():
+            if isinstance(function_components, dict):
+                group = function_components.get(f"{function_name}_group")
+                text_output = function_components.get(f"{function_name}_text")
+                markdown_output = function_components.get(f"{function_name}_markdown")
+                
+                if all([group, text_output, markdown_output]):
+                    updates.extend([
+                        group.update(visible=True),
+                        text_output.update(visible=True, value="Generating..."),
+                        markdown_output.update(visible=True, value="Generating...")
+                    ])
+        
+        return updates
+    except Exception as e:
+        print(f"Error in make_components_visible: {str(e)}")
+        return [progress_update.update(value=f"Error: {str(e)}")]
+
+def handle_prd_generation(progress_update):
+    """Handle PRD and component generation"""
+    try:
+        # Create a list to collect all components that need to be updated
+        output_components = []
+        
+        # Get the results from the project one by one
+        for function_name, result in state.quotation_project.generate_prd_and_components():
+            print(f"Received result for {function_name}")
+            
+            # Get the corresponding components using the function name
+            function_components = components.get(function_name, {})
+            if function_components:
+                # Get all components - note the change from accordion to group
+                group = function_components.get(f"{function_name}_group")
+                text_output = function_components.get(f"{function_name}_text")
+                markdown_output = function_components.get(f"{function_name}_markdown")
+                
+                if all([group, text_output, markdown_output]):
+                    # Add components to the output list - no more accordion
+                    output_components.extend([
+                        group,
+                        text_output,
+                        markdown_output
+                    ])
+                    
+                    # Update the components with content
+                    text_output.update(value=result)
+                    markdown_output.update(value=result)
+                    
+                    # Update progress
+                    progress_update.update(value=f"Generated output for {function_name}")
+                    print(f"Updated components for {function_name}")
+        
+        # Return all components that were updated plus the progress update
+        print(f"Returning {len(output_components)} components")
+        return [progress_update] + output_components
+        
+    except Exception as e:
+        print(f"Error in handle_prd_generation: {str(e)}")
+        # Return updates to hide all components on error
+        return [progress_update.update(value=f"Error: {str(e)}")] + [gr.update(visible=False) for _ in range(len(components)*3)]
+
+def setup_all_handlers(step_buttons, all_components, progress_update, quotation_cost, upload_drive_btn, upload_notion_btn, recalc_btn, project_name):
+    """Set up all step handlers with the provided UI components"""
+    
+    # Store components for use in handlers
+    global components
+    components = all_components
+    
+    # Get all possible output components for the handler
+    output_components = []
+    for function_name, function_components in components.items():
+        if isinstance(function_components, dict):
+            group = function_components.get(f"{function_name}_group")
+            text = function_components.get(f"{function_name}_text")
+            markdown = function_components.get(f"{function_name}_markdown")
+            if all([group, text, markdown]):
+                output_components.extend([group, text, markdown])
+    
+    # Set up handlers for each step button
+    for step_name, button in step_buttons.items():
+        if "Step 1" in step_name:
+            button.click(
+                fn=make_components_visible,
+                inputs=[progress_update],
+                outputs=[progress_update] + output_components
+            ).then(
+                fn=handle_prd_generation,
+                inputs=[progress_update],
+                outputs=[progress_update] + output_components
+            )

event_handlers.py

@@ -1,133 +0,0 @@
-from Project import * 
-from google_drive import *
-from notion import upload_to_notion 
-from page_prompts_config import *
-
-def setup_all_handlers(step_buttons, all_components, page_progress_update, quotation_cost, page_recalc_btn, page_upload_drive_btn, page_upload_notion_btn, project_name): 
-    """Set up all step handlers with the provided UI components""" 
-      
-    # Step 1 handler remains unchanged
-    step_buttons['Step 1 : Scope & Components'].click( 
-        fn=state.quotation_project.generate_prd_and_components,
-        inputs=[], 
-        outputs=[ 
-            all_components['generate_prd']['generated_prd_text'], 
-            all_components['generate_prd']['generated_prd_markdown'], 
-            all_components['generate_plan_test_components']['generated_plan_test_components_text'], 
-            all_components['generate_plan_test_components']['generated_plan_test_components_markdown'], 
-            all_components['generate_dev_components']['generated_dev_components_text'], 
-            all_components['generate_dev_components']['generated_dev_components_markdown'], 
-            all_components['reformat_dev_components']['reformatted_dev_components_text'], 
-            all_components['reformat_dev_components']['reformatted_dev_components_markdown'], 
-            page_progress_update 
-        ], 
-    ) 
-
-    # Step 2.1: Generate initial mandays
-    step_buttons['Step 2.1 : Generate Mandays'].click( 
-        fn=state.quotation_project.generate_mandays, 
-        inputs=[ 
-            all_components['generate_plan_test_components']['generated_plan_test_components_text'], 
-            all_components['reformat_dev_components']['reformatted_dev_components_text'], 
-        ], 
-        outputs=[ 
-            all_components['generate_plan_test_mandays']['generated_plan_test_mandays_dataframe'], 
-            all_components['generate_dev_mandays']['generated_dev_mandays_dataframe'], 
-            page_progress_update 
-        ], 
-    ) 
-
-    # Step 2.2: Analyze components
-    step_buttons['Step 2.2 : Analyze Components'].click( 
-        fn=state.quotation_project.analyze_components,
-        inputs=[], 
-        outputs=[
-            page_progress_update
-        ], 
-    ) 
-
-    # Step 2.3: Generate MVP estimates
-    step_buttons['Step 2.3 : Recalculate MVP Mandays'].click( 
-        fn=state.quotation_project.generate_mvp_estimates,
-        inputs=[],  
-        outputs=[ 
-            all_components['generate_MVP_mandays']['generated_MVP_mandays_dataframe'], 
-            page_progress_update, 
-            quotation_cost 
-        ], 
-    ) 
-
-    # Step 3 handler remains unchanged
-    step_buttons['Step 3 : Final Documentation'].click( 
-        fn=state.quotation_project.generate_sow,
-        inputs=[ 
-            all_components['generate_prd']['generated_prd_text'], 
-            all_components['generate_plan_test_components']['generated_plan_test_components_text'], 
-            all_components['reformat_dev_components']['reformatted_dev_components_text'], 
-            all_components['generate_MVP_mandays']['generated_MVP_mandays_dataframe'],
-            quotation_cost 
-        ], 
-        outputs=[ 
-            all_components['generate_mvp_prd']['generated_mvp_prd_text'],
-            all_components['generate_mvp_prd']['generated_mvp_prd_markdown'],
-            all_components['generate_BD_SOW']['generated_BD_SOW_text'], 
-            all_components['generate_BD_SOW']['generated_BD_SOW_markdown'], 
-            all_components['generate_Tech_SOW']['generated_Tech_SOW_text'], 
-            all_components['generate_Tech_SOW']['generated_Tech_SOW_markdown'], 
-            page_progress_update 
-        ], 
-    ) 
-
-    # Recalculate button handler
-    page_recalc_btn.click( 
-        fn=state.quotation_project.recalculate_cost, 
-        inputs=[ 
-            all_components['generate_plan_test_mandays']['generated_plan_test_mandays_dataframe'], 
-            all_components['generate_dev_mandays']['generated_dev_mandays_dataframe'], 
-            all_components['generate_MVP_mandays']['generated_MVP_mandays_dataframe'],
-        ],  
-        outputs=[ 
-            quotation_cost, 
-            page_progress_update 
-        ] 
-    ) 
-
-    # Upload to Google Drive handler
-    page_upload_drive_btn.click( 
-        fn=upload_to_gdrive, 
-        inputs=[ 
-            project_name, 
-            all_components['generate_prd']['generated_prd_text'], 
-            all_components['generate_plan_test_components']['generated_plan_test_components_text'], 
-            all_components['reformat_dev_components']['reformatted_dev_components_text'], 
-            all_components['generate_plan_test_mandays']['generated_plan_test_mandays_dataframe'], 
-            all_components['generate_dev_mandays']['generated_dev_mandays_dataframe'], 
-            all_components['generate_MVP_mandays']['generated_MVP_mandays_dataframe'],
-            all_components['generate_mvp_prd']['generated_mvp_prd_text'],
-            quotation_cost, 
-            all_components['generate_BD_SOW']['generated_BD_SOW_text'], 
-            all_components['generate_Tech_SOW']['generated_Tech_SOW_text'], 
-        ],  
-        outputs=[page_progress_update] 
-    ) 
-    
-    # Upload to Notion handler
-    page_upload_notion_btn.click(
-        fn=upload_to_notion, 
-        inputs=[ 
-            project_name,
-            all_components['generate_prd']['generated_prd_text'], 
-            all_components['generate_plan_test_components']['generated_plan_test_components_text'], 
-            all_components['reformat_dev_components']['reformatted_dev_components_text'], 
-            all_components['generate_plan_test_mandays']['generated_plan_test_mandays_dataframe'], 
-            all_components['generate_dev_mandays']['generated_dev_mandays_dataframe'], 
-            all_components['generate_MVP_mandays']['generated_MVP_mandays_dataframe'],
-            all_components['generate_mvp_prd']['generated_mvp_prd_text'],
-            quotation_cost, 
-            all_components['generate_BD_SOW']['generated_BD_SOW_text'], 
-            all_components['generate_Tech_SOW']['generated_Tech_SOW_text'], 
-        ],  
-        outputs=[page_progress_update] 
-    )
-
-

page_prompts_config.py

@@ -1,938 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-from typing import List, Dict, Any, Optional
-
-class ModelType(Enum):
-    O1_MINI = "o1-mini"
-    O4_MINI = "gpt-4o-mini"
-
-class UIComponentType(Enum):
-    TEXTBOX = "textbox"
-    MARKDOWN = "markdown"
-    DATAFRAME = "dataframe"
-    BUTTON = "button"
-
-
-@dataclass
-class UIConfig:
-    component_type: UIComponentType
-    label: str
-    default_value: Any = None
-    visible: bool = True
-    interactive: bool = True
-    lines: Optional[int] = None
-    description: str = ""
-    show_copy_button: bool = False
-    elem_classes: Optional[List[str]] = None
-
-@dataclass
-class PromptConfig:
-    prompt: str
-    inputs: List[str]
-    outputs: List[str]
-    model: ModelType
-    description: str = ""
-    step: str = ""
-    sub_step: str = ""
-    ui: Dict[str, UIConfig] = None
-
-PROMPTS = {
-    "client_initial_question": PromptConfig(
-        prompt=
-        """
-        # Client Information Gathering Questions
-        
-        ### Company Background and Industry
-        1. Can you provide some background about your company?
-        2. Which industry do you operate in, and what is your company's niche or specialization?
-        3. Who are your primary customers?
-        4. What are the main objectives you want to achieve?
-        5. What key features or functionalities do you need?
-        
-        ### Current Challenges
-        6. What are the biggest challenges your firm is currently facing?
-        7. Can you describe your current processes?
-        
-        ### Workflow and System Impact
-        8. How will this solution benefit your firm as a whole?
-        
-        ### Existing Workflow or System
-        9. Can you describe your current workflow or system?
-        
-        ### Pain Point Identification
-        10. Where is your current system falling short or causing delays?
-        11. Are there any parts of the process that are particularly time-consuming/ prone to error?
-        """,
-        inputs=[],
-        outputs=[],
-        model=ModelType.O1_MINI,
-        description="Client Initial Question",
-        step="Chatbot Prompt Editors",
-        ui={
-            "client_initial_question_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Client Initial Questions",
-                interactive=True,
-                lines=20
-            )
-        }
-    ),
-
-    "generate_client_follow_up": PromptConfig(
-        prompt=
-        """
-        Based on the initial list of questions and the client's provided answers, generate **insightful and targeted follow-up questions** that will help deepen my understanding of the following critical aspects:
-        
-        1. **Client Overview**  
-           **Objective:** ask relevant questions that will directly contribute to better project requirements gathering. (ie: department team that the project is meant for ..etc)
-        
-        2. **Project Vision and Value**  
-           **Objective:** Clarify the intended impact of the project on the client's business. Understand how it will improve their processes, solve key challenges, and deliver measurable benefits.  
-           **Focus:** Investigate specific outcomes, immediate expected goals, and how success will be defined.
-        
-        3. **Existing System or Workflow Description**  
-           **Objective:** Delve deeper into the client's current tools, workflows, and processes to uncover pain points, integration requirements, and opportunities for optimization.  
-           **Focus:** Identify inefficiencies, technical limitations, or gaps that the project will address.
-        
-        4. **Budget and Resource Constraints**  
-           **Objective:** Clearly define any limitations or constraints—financial, resource-based, or time-related—that could impact project success.  
-           **Focus:** Understand the flexibility of the budget, timeline expectations, and resource availability.
-        
-        Instructions:
-        Each question should:
-        Build on provided client information
-        Non repetitive, and unique. Avoid asking similar questions.
-        Include realistic sample answers relevant to the client's context
-        Focus on gathering quantifiable or specific information
-        
-        
-        Output top 10 questions in the following format: 
-        <question>(sample answers)
-        Just return the text and NOTHING else. Do not overexplain, omit code guards.
-        """,
-        inputs=['project_detail'],
-        outputs=['client_follow_up_questions'],
-        model=ModelType.O1_MINI,
-        description="Generate Client Follow-up Questions",
-        step="Chatbot Prompt Editors",
-        ui={
-            "client_follow_up_quetions_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Client Follow-up Questions",
-                interactive=True,
-                lines=20
-            )
-        }
-    ),
-    
-    "gather_project_input": PromptConfig(
-        prompt=
-        """
-        **You are a Software Development Expert specializing in scalable, secure, and robust document processing systems. 
-          You will be provided with client background information.
-          Your task is to create a dynamic, context-aware list of questions to collaboratively gather client requirements for a document processing application. 
-          Use the list below 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 Sample Answers as guidance to the client to answer the questions.
-          ### Areas to Cover:
-          ---
-          Document Types:
-          <client context>, What specific types of documents will the application need to process (e.g., invoices, legal contracts, ID forms)? 
-          <client context>, Are there specific complexities or variations in these documents that we should account for (e.g., multi-page documents, handwritten content)?
-          Inputs and Outputs:
-          <client context>, What are the expected input formats (e.g., PDFs, images, scanned documents)?
-          <client context>, What should the processed outputs look like (e.g., structured data, summaries, reports)?
-          <client context>, Are there any specific formatting requirements for outputs?
-          Document Quality:
-          <client context>, Are the documents typically clean and structured, or will the application need preprocessing capabilities (e.g., OCR, noise reduction)?
-          <client context>, Do you foresee any challenges with document quality, such as low resolution or inconsistent formatting?
-          Workflow Mapping:
-          <client context>, Can you describe your current document processing workflow?
-          <client context>, What are the major pain points or inefficiencies in the current process?
-          <client context>, Which parts of the workflow involve manual interventions, and how would you like to streamline them?
-          Integration Points:
-          <client context>, What existing systems or third-party tools does the application need to integrate with (e.g., CRMs, ERPs, cloud storage, OCR tools)?
-          <client context>, Are there specific APIs, databases, or platforms already in use that we need to consider?
-          Security and Compliance:
-          <client context>, What security measures are required to protect the data processed by the application?
-          <client context>, Are there any industry-specific compliance standards the application must adhere to (e.g., GDPR, HIPAA)?
-          Scalability and Performance:
-          <client context>, What is the expected volume of documents the application should handle on a daily/weekly/monthly basis?
-          <client context>, Are there performance benchmarks or response time requirements that the application must meet?
-          User Management and Access Control:
-          <client context>, What user roles and permissions will be needed within the application?
-          <client context>, How should user authentication and authorization be managed?
-          Reporting and Analytics:
-          <client context>, What types of analytics or reporting capabilities do you require within the application?
-          <client context>, Do you need real-time reporting, or are batch processes sufficient?
-          Deployment and Maintenance:
-          <client context>, Do you have any preferences for the deployment environment (e.g., cloud-based, on-premises)?
-          <client context>, What are your requirements for application maintenance and support post-deployment?
-          
-          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'],
-        outputs=['gathered_project_input'],
-        model=ModelType.O1_MINI,
-        description="Generate Context-Aware List Of Questions",
-        step="Chatbot Prompt Editors",
-        ui={
-            "gather_project_input_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Gather Project Input Prompt",
-                lines=20,
-                interactive=True
-            )
-        }
-    ),
-
-    "review_project_input": 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=['reviewed_project_input'],
-        model=ModelType.O1_MINI,
-        description="Review project input",
-        step="Chatbot Prompt Editors",
-        ui={
-            "review_project_input_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Review Project Input Prompt",
-                lines=20,
-                interactive=True
-            )
-        }
-    ),
-
-    "generate_prd": PromptConfig(
-        prompt=
-        """
-        Rewrite this for clarity while keeping ALL specific details, metrics, and constraints.
-        Please take note of the time constraint to build the MVP.
-        Do not include context or assumptions beyond the input provided.
-        Do not also exclude any input provided.
-        Structure the document to ensure clarity and logical flow.
-        Make sure to make the title "Project Requirements".
-        """,
-        inputs=["project_detail"],
-        outputs=["generated_prd"],
-        model=ModelType.O1_MINI,
-        description="Step 1.1 : Generate Project Requirements Document (PRD)",
-        step="Step 1 : Scope & Components",
-        ui={
-            "requirement_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Requirements(PRD) System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_prd_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Requirements(PRD) Output",
-                lines=20,
-                visible=True
-            ),
-            "generated_prd_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="Requirements(PRD) Output",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-
-    "generate_plan_test_components": PromptConfig(
-        prompt=
-        """
-        Context:
-        You are an expert in software project planning and testing. Your task is to create a highly detailed, actionable, and project-specific Component List for a software 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 ( Potention Focus: Requirement gathering,Technical architecture design, Resource Allocation.. etc)
-        2. Testing Phase ( Potention Focus: Integration testing, System testing, User Acceptance Testing (UAT) )
-        
-        Components:
-        For each phase, include project-specific components that align with the goal of developing the software Project. Break down each phase into granular sub-components, ensuring specificity and alignment with the PRD.
-        Use the PRD to extract relevant, granular components that reflect deliverables unique to this project.
-        
-        Output Format:
-        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="Step 1.2 : Generate planning and testing components",
-        step="Step 1 : Scope & Components",
-        ui={
-            "plan_test_component_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Plan Test System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_plan_test_components_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Plan & Test Components Output",
-                lines=20,
-                visible=True
-            ),
-            "generated_plan_test_components_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="Plan & Test Components Output",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-
-    "generate_dev_components": PromptConfig(
-        prompt=
-        """
-        As a Senior Software Architect with 20+ years of experience, you are tasked to generate a detailed, actionable, and project-specific component list exclusively for the development phase of the project. The list must align with the project's goals, technical stack, and compliance requirements as outlined in the provided Project Requirement Document (PRD), ensuring granularity and specificity.
-        
-        **Specific Requirements:**
-        1. Extract relevant **granular components** from the PRD that reflect the tasks and deliverables unique to this project.
-        2. Components should directly reference functionalities or deliverables related to the project.
-        3. Prioritize components that provide high business value, such as core functionality.
-        4. Organize components into logical categories such as Frontend, Backend, Integration Development, etc., with further subdivisions as needed. Avoid Testing, Support and Maintenance, Documentation, and Training components.
-        5. Ensure deliverables focus entirely on outcomes and deliverables, and consider edge cases, avoiding unnecessary instructions (i.e., avoid filler words).
-        6. Identify key business logic and special edge cases that need to be considered during development, which could impact the system's robustness or functionality.
-        7. **Include a separate section titled "Special Edge Cases Considerations"** to explicitly address unhappy paths. The deliverables in this section should focus solely on development outcomes to address these scenarios.
-        
-        **Output Format:**
-        - Title: Component Name as Table Title (e.g., "Frontend Components")
-        - Table Structure:
-        - **Subcomponent**: Subcomponent name (e.g., "User Authentication and Authorization").
-        - **Task**: Task name (e.g., "Login Interface").
-        - **Deliverables**: Lists of technical outcomes or deliverables (e.g., "1. Deliverable 1  2. Deliverable 2  3. Deliverable ..."), as much as possible.
-        - **Special Edge Cases Considerations**: A separate table to address unhappy paths, with the same structure as above.
-        
-        **Example:**
-        Frontend Component
-        | **Component**               | **Task**                     | **Deliverables**                                                                                         |
-        |--------------------------------|------------------------------|----------------------------------------------------------------------------------------------------------|
-        | Document Upload Interface      | Implement File Upload        | 1. React-based file upload component<br>2. Drag-and-drop functionality<br>3. Progress bar for uploads    |
-        
-        **Special Edge Cases Considerations**
-        | **Component**               | **Task**                     | **Deliverables**                                                                                         |
-        |--------------------------------|------------------------------|----------------------------------------------------------------------------------------------------------|
-        | Input Validation               | Handle Invalid Inputs        | 1. File format validation logic<br>2. File size validation logic<br>3. Error messaging UI for invalid inputs |
-        
-        **Tech Stack:**
-        - Backend: FastAPI, Python
-        - Frontend: React
-        - Infrastructure: AWS, PostgreSQL, Redis, Docker, Alembic
-        
-        **Objective:**
-        The final output should deliver a **clear, actionable, and project-specific list of components**, with a separate section for handling unhappy paths. The goal is to provide a foundation for developing granular subcomponents and tasks, ensuring alignment with the unique requirements of this project. A logical grouping and a clean structure that enhance the table's clarity and technical usability is expected.
-        """,
-        inputs=["generated_prd"],
-        outputs=["generated_dev_components"],
-        model=ModelType.O1_MINI,
-        description="Step 1.3 : Generate development components",
-        step="Step 1 : Scope & Components",
-        ui={
-            "dev_component_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX, 
-                label="Development System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_dev_components_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Development Components Output",
-                lines=20,
-                visible=True
-            ),
-            "generated_dev_components_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="Developemnt Components Output",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-    
-    "reformat_dev_components": PromptConfig(
-        prompt=
-        """
-        As a Senior Software Architect with 20+ years of experience, you are tasked to reformat the generated development components for a document extraction project to ensure consistent and standardized naming conventions. The reformatted components must align with the project's goals, technical stack, and compliance requirements as outlined in the provided Project Requirement Document (PRD).
-        
-        **Specific Requirements:**
-        1. **Standardize Naming Conventions**:
-        - Use **descriptive and intuitive names** for components, subcomponents, tasks, and deliverables.
-        - Ensure naming is **consistent across all tables** (Frontend, Backend, Integration, Infrastructure, Database, and Special Edge Cases).
-        - Avoid overly technical jargon unless necessary for clarity.
-        - Use **action-oriented language** for tasks and deliverables (e.g., "Implement file upload functionality" instead of "File upload functionality").
-        
-        2. **Common Web Development Document Extraction Components**:
-        - Include standard components such as:
-        - **Document Upload Interface**
-        - **Document Processing Engine**
-        - **Data Validation Module**
-        - **OCR Integration**
-        - **Data Reconciliation Module**
-        - **Report Generation Interface**
-        - **User Authentication and Authorization**
-        - **Notification and Alert System**
-        - **API Integrations**
-        - **Database Schema Design**
-        - **Error Handling and Logging**
-        - **Scalability and Load Balancing**
-        
-        3. **Reformat the Generated Components**:
-        - Ensure all components, subcomponents, tasks, and deliverables follow the standardized naming conventions.
-        - Group related tasks and deliverables under the appropriate subcomponents.
-        - Maintain a clean and logical structure for readability and technical usability.
-        
-        **Output Format:**
-        - Title: Component Name as Table Title (e.g., "Frontend Components")
-        - Table Structure:
-        - **Subcomponent**: Subcomponent name (e.g., "Document Upload Interface").
-        - **Task**: Task name (e.g., "Implement file upload functionality").
-        - **Deliverables**: Lists of technical outcomes or deliverables
-        """,
-        inputs=["generated_dev_components"],
-        outputs=["reformatted_dev_components"],
-        model=ModelType.O1_MINI,
-        description="Step 1.4 : Reformat development components",
-        step="Step 1 : Scope & Components",
-        ui={
-            "reformatted_dev_components_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Reformatted Development Components",
-                lines=20, 
-                interactive=True
-            ),
-            "reformatted_dev_components_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Reformatted Development Components Output",
-                lines=20,
-                visible=True
-            ),
-            "reformatted_dev_components_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="Reformatted Development Components Markdown Output",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-
-    "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.
-        
-        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
-            )
-        }
-    ),
-    
-    "generate_dev_mandays": PromptConfig(
-        prompt=
-        """
-        You are an experienced project manager tasked to create a detailed task breakdown for development components.
-        
-        Objective:
-        Generate a structured CSV output with manday estimates for each development component and subcomponent from the provided development component list.
-        
-        Critical CSV Format Requirements:
-        1. First line MUST be exactly: component,subcomponent,mandays,description
-        2. Each subsequent line MUST contain actual data with:
-        - component: quoted text (e.g., "Frontend", "Backend")
-        - subcomponent: quoted text (e.g., "User Authentication", "API Development")
-        - mandays: unquoted number between 0.5 and 7 (e.g., 3.5, 2.0)
-        - description: quoted text describing the work
-        3. No empty lines or missing values
-        4. Text values must be in double quotes
-        5. Numbers must not be in quotes
-        
-        Example Valid Output:
-        component,subcomponent,mandays,description
-        "Frontend","User Authentication",3.5,"Implementation of login/logout functionality with security features"
-        "Frontend","Dashboard UI",2.5,"Development of main dashboard interface with data visualization"
-        "Backend","API Development",4,"Development of REST APIs for data processing"
-        "Backend","Database Integration",2,"Implementation of database connections and queries"
-        "Infrastructure","Docker Setup",1.5,"Container configuration and deployment setup"
-        "Infrastructure","CI/CD Pipeline",2,"Setup of automated build and deployment pipeline"
-        
-        Instructions:
-        1. Parse the provided development component list
-        2. For EACH component and subcomponent in the list:
-        - Create at least one row in the CSV
-        - Estimate realistic mandays (0.5-7 days)
-        - Write clear descriptions
-        3. Return ONLY the CSV content - no explanations or code blocks
-        
-        YOU MUST GENERATE ACTUAL DATA ROWS based on the development component list provided.
-        """,
-        inputs=["reformatted_dev_components"],
-        outputs=["generated_dev_mandays"],
-        model=ModelType.O1_MINI,
-        description="Step 2.1 : Generate development mandays",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.1 : Generate Mandays",
-        ui={
-            "dev_mandays_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Dev Mandays System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_dev_mandays_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="Dev Mandays",
-                interactive=True
-            )
-        }
-    ),
-    
-    "generate_mvp_prd": PromptConfig(
-        prompt=
-        """
-        Generate a comprehensive and structured Project Requirement Document (PRD) for a Minimum Viable Product (MVP) using the following inputs:
-        1. **General PRD Guidelines**: Use the provided general PRD as a framework for structure, tone, and level of detail. This includes sections like Introduction, Scope, Functional Requirements, Non-Functional Requirements, Technical Architecture, Workflow, Testing, Deployment, and Appendices.
-        2. **MVP Components**: Incorporate the specific MVP components, including their descriptions, mandays estimates, and functionalities, into the relevant sections of the PRD. Ensure all details are accurately reflected.
-        
-        Follow these instructions:
-        - Retain ALL specific details, metrics, and constraints from both the general PRD and MVP components.
-        - Pay special attention to the time constraint for building the MVP, as outlined in the inputs.
-        - Do not add any context or assumptions beyond the provided inputs.
-        - Do not exclude any details from the inputs.
-        - Structure the document to ensure clarity, logical flow, and readability and use tabular format whenever possible.
-        - Use the title "Project Requirements" for the document.
-        
-        The output should be a well-organized PRD that combines the general PRD guidelines with the specific MVP components, ensuring alignment with the project's goals and constraints.
-        """,
-        inputs=["generated_prd" , "mvp_components"],
-        outputs=["generated_mvp_prd"],
-        model=ModelType.O1_MINI,
-        description="Step 3.1 : Generate MVP PRD",
-        step="Step 3 : Final Documentation",
-        ui={
-            "mvp_prd_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="MVP PRD System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_mvp_prd_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="MVP PRD Output",
-                lines=20,
-                visible=True
-            ),
-            "generated_mvp_prd_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="MVP PRD Output",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-    
-    "generate_BD_SOW": PromptConfig(
-        prompt=
-        """
-        As an project manager with 20+ years of experience, you are tasked to create a detailed Scope of Work (SOW) document. Analyze the provided project component list and scope document to generate the following sections. Follow the guidelines below to ensure a professional, structured, and client-ready output:
-        
-        ### **Scope of Work (SOW)**
-        #### **1. Project Background**
-        - Provide a brief overview of the project, including the context, problem statement, and why the project is being initiated.
-        - Break down key challenges (in bullet point) the company currently facing, quantifying the impacts where possible (e.g., lost revenue, downtime).
-        - Close this section with industry trends or other relevant background information, emphasizing risks of inaction leading to the project, in 2-3 sentenc
-        #### **2. Project Objective**
-        - Clearly define the project's primary goals and what constitutes success, using the following structure:
-        - Goals: List specific, measurable goals (e.g., reduce processing time by 20%).
-        - Outcomes: Describe tangible deliverables and metrics for succe
-        #### **3. Project Buyers & Stakeholders**
-        - List key stakeholders involved in the project, e.g. buyers, end-users, and decision-makers.
-        - Identify their name and roles in the project, using a tab
-        #### **4. System Flow**
-        - Provide description of how the system components interact, describing what each module does and how it works.
-        - Use one of the following:
-        - Visual Representation: Diagram illustrating workflows or data flows between modules.
-        - Textual Description: Detailed explanation of the processes and transitions
-        - Use bullet point, ensure simplicity and avoid overly technical language
-        #### **5. Modules and Functional Requirements Breakdown**
-        - LEAVE THIS BLANK
-        #### **6. Acceptance Criteria**
-        - Define conditions to be met, including specific, measurable criteria for project completion:
-        - Link each deliverable/module to its validation or testing process (e.g., UAT).
-        - Table format with the following column:
-        - Deliverable (e.g. Field Matching Automation module)
-        - Criteria, starting with "able to" (e.g. able to extract, match, and change the case status according
-        #### **7. Assumptions and Pre-requisites**
-        - List all planning-phase assumptions and pre-requisites, grouped into:
-        - Assumptions: Detailed, scenario-based assumptions that the project relies on. Each assumption should:
-        - Reference specific stakeholders (e.g., PWT staff, Mindhive).
-        - Describe specific conditions or expectations (e.g., document quality, workflow stability).
-        - Be written in clear, concise language.
-        - Pre-requisites or dependencies: Conditions that must be met before the project can proceed. Each pre-requisite should:
-        - Be specific and actionable.
-        - Reference who is responsible and what needs to be do
-        #### **8. Proposed Timeline**
-        - Provide a project timeline, including:
-        - Milestone
-        - Expected Date/Duration
-        - Outcome/Deliverable
-        - Use a Gantt chart or table to visualize the timeline.
-        - Ensure the output are clean, organized, and easy to read
-        #### **9. Commercial**
-        Summarize the project's commercial details in the following subsections:
-        - Development Fee: Create a table summarizing the costs for development, including the product, technical work supporting, or other additional services provided
-        - Subscription Fee: If applicable, create a table summarizing subscription fees for system usage.
-        - Payment Terms: Include a text description of payment terms:
-        - Milestones: Specify at which stages payments are due
-        - Invoicing: Define invoicing intervals (e.g., monthly, quarterly) and payment deadlines
-        - Other Terms: Mention late payment fees or additional terms, if applicable
-        - Output Format for tables: {Service}, {Fee} (leave amount blank)
-        #### **10. Sign-Off**
-        - Create a professional and formal Sign-Off section  to acknowledge and approve the SOW.
-        - Include an statement to clearly communicate that both parties have reviewed and agreed to the SOW.
-        - Provide placeholder for each party (Company):
-        - Signature
-        - Name
-        - Position
-        - Date
-        #### **Guidelines**
-        - Use bullet points for clarity.
-        - Keep descriptions concise and client-friendly; avoid technical jargon unless necessary.
-        - Maintain structured sections and tables for readability.
-        Expected output should be professional, well-structured, and designed to help clients and stakeholders clearly understand the project scope. I'm going to tip you for a better outcome!
-        """,
-        inputs=["generated_prd", "generated_plan_test_components", "reformatted_dev_components", "quotation_cost"],
-        outputs=["generated_BD_SOW"],
-        model=ModelType.O1_MINI,
-        description="Step 3.2 : Generate BD SOW",
-        step="Step 3 : Final Documentation",
-        ui={
-            "BD_SOW_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="BD SOW System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_BD_SOW_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="BD SOW Doc",
-                lines=20,
-                visible=True
-            ),
-            "generated_BD_SOW_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="BD SOW Doc",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-    
-    "generate_Tech_SOW": PromptConfig(
-        prompt=
-        """
-        As an experienced project manager with over 20 years of expertise, you are tasked to create a detailed Scope of Work (SOW) document in JSON format. The JSON output should contain markdown-formatted strings as values for each section of the SOW. Analyze the provided project component list and scope document to generate the following sections:
-        
-        ### **Scope of Work (SOW)**
-        
-        #### **1. Scope Summary**
-        - Provide a concise, high-level overview of the project scope. Divide it into three subsections:
-        - **In Scope:**
-          - List all deliverables, functionalities, and modules included in the project.
-          - Be specific about what will be developed, implemented, or delivered.
-          - Include MVP components (e.g., basic features, functionality, UI, document processing).
-        - **Assumptions:**
-          - Highlight key project-specific assumptions that the project relies on.
-        - **Dependencies:**
-          - List all internal and external dependencies required for the project's success.
-          - Include any third-party integrations, resources, or timelines that the project depends on.
-        
-        #### **2. Modules and Functional Requirements Breakdown**
-        - Break down the project into modules or components.
-        - Present the details in a succinct and client-friendly table with the following columns:
-          - **Module**
-          - **Functionalities/Features**
-          - **Notes for any special considerations or constraints (e.g., 'Supports files up to 100MB')**
-        - Use clear, concise, non-technical language. (e.g., 'Drag-and-drop support for PDFs, Excel, CSV; progress indicators'). Avoid excessive detail.
-        - Include MVP components as part of the breakdown and provide clear functionalities related to those (e.g., basic document upload, UI features, data processing).
-        
-        #### **3. Out of Scope**
-        - Explicitly define what is excluded from the project's scope. This may include any functionalities, tasks, or deliverables.
-        - Ensure clarity to prevent future misunderstandings.
-        
-        #### **4. System Flow**
-        - Provide a detailed, step-by-step description of how the system components interact.
-        - For each component or module:
-          - Describe what it does and how it works, including both success and unsuccessful scenarios.
-          - Explain how it interacts with other components.
-        - Include MVP-related components in the system flow, describing their function and interaction within the MVP's framework.
-        
-        Output Requirements:
-        Just return the JSON object and nothing else, omit code guards ```, where each key represents a section of the SOW, and the value is a markdown-formatted string for that section.
-        Use clear, concise, and client-friendly language. Avoid excessive technical jargon unless necessary.
-        Example JSON Output:
-        {
-        "scope_summary": <markdown content>,
-        "modules_and_functional_requirements": <markdown content>,
-        "out_of_scope": <markdown content>,
-        "system_flow": <markdown content>
-        }
-        """,
-        inputs=["generated_plan_test_components", "reformatted_dev_components" ,"mvp_components"],
-        outputs=["generated_Tech_SOW"],
-        model=ModelType.O1_MINI,
-        description="Step 3.3 : Generate Tech SOW",
-        step="Step 3 : Final Documentation",
-        ui={
-            "Tech_SOW_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Technical SOW System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_Tech_SOW_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Technical SOW Doc",
-                lines=20,
-                visible=True
-            ),
-            "generated_Tech_SOW_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="Technical SOW Doc",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),    
-
-    "analyze_planning_testing_mandays": PromptConfig(
-        prompt=
-        """
-        You are an experienced project manager tasked with analyzing the provided planning and testing mandays estimates. Your goal is to identify the highest priority components that must be completed to build the MVP. Focus on components that deliver **immediate value to users** and are **critical for the core functionality** of the product.
-        
-        Objective:
-        Identify the highest priority planning and testing components that are critical for the MVP's core functionality and deliver immediate value to the business. Exclude all non-critical components that do not directly contribute to the MVP's primary functionality.
-        
-        Key Guidelines:
-        - Focus on Core Functionality: Only include components that are essential for the MVP to function and deliver immediate value to users.
-        - Exclude Non-Critical Components: Do not include components related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is not absolutely necessary for the MVP.
-        - Prioritize Business Value: Ensure the selected components align with the business's core objectives and deliver measurable value.
-        - Minimalistic Approach: Focus on the least effort required to deliver the most value.
-        
-        Output Format Requirements:
-        - Provide a clear list of identified priority planning/testing components with a brief justification for each selection.
-        - Ensure the output is concise and actionable.
-        """,
-        inputs=["generated_plan_test_mandays"],
-        outputs=["identified_planning_testing_components"],
-        model=ModelType.O1_MINI,
-        description="Step 2.2 : Analyze planning and testing components",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.2 : Analyze Components",
-        ui={
-            "planning_testing_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Plan & Test Components Analysis Prompt",
-                lines=20,
-                interactive=True
-            ),
-        }
-    ),
-    
-    "analyze_development_mandays": PromptConfig(
-        prompt=
-        """
-        You are an experienced project manager tasked with analyzing the provided development mandays estimates. Your goal is to assign a priority level to each development component based on its importance to the MVP's core functionality and business value. Focus exclusively on components that deliver immediate value to users and are critical for the core functionality of the product.
-        
-        Key Guidelines:
-        - **Focus on Core Functionality:** Assign priority levels based on how essential each component is for the MVP to function and deliver immediate value to users.
-        - **Exclude Non-Critical Considerations:** Do not label components related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is **NOT** absolutely necessary for the MVP as "high" priority.
-        - **Prioritize Business Value:** Ensure the priority levels align with the business's core objectives and deliver measurable value.
-        - **Minimalistic Approach:** Focus on the least effort required to deliver the most value when assigning priority levels.
-        - **Assign Priority Levels:** Label each development component as "high," "medium," or "low" priority based on its importance to the MVP's core functionality and business value.
-        
-        Objective:
-        Assign a priority level ("high," "medium," or "low") to each development component, ensuring the output reflects the importance of each component to the MVP's core functionality and business value. Retain all original components in the list.
-        
-        Output Format Requirements:
-        - Provide a list of all development components with their assigned priority levels.
-        - Include a "Priority" column labeling each component as "high," "medium," or "low."
-        - Ensure the output is concise and actionable.
-        
-        Important Notes:
-        - If a component is not directly tied to the core functionality or can be deferred to a later phase, assign it a lower priority ("medium" or "low").
-        - Do not exclude any components from the list, even if they are low priority.
-        - Only assign "high" priority to components that are absolutely necessary for the MVP to function.
-        """,
-        inputs=["generated_dev_mandays"],
-        outputs=["identified_development_components"],
-        model=ModelType.O1_MINI,
-        description="Step 2.2 : Analyze development components",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.2 : Analyze Components",
-        ui={
-            "development_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Development Components Analysis Prompt",
-                lines=20,
-                interactive=True
-            ),
-        }
-    ),
-
-    "recalculate_mandays": PromptConfig(
-        prompt=
-        """
-        Based on the identified priority components from the previous analysis, your task is to recalculate the mandays estimates to ensure they fit within the time given (e.g., days or weeks) in building the MVP mentioned in the Project Requirement Document (PRD).
-        
-        Objective:
-        Reread the entire PRD to identify the timelimit of the MVP, then Recalculate the manday estimates for the identified priority development components  to ensure they fit within the timeline specified in the Project Requirement Document (PRD) to build the MVP. Adjust development mandays while maintaining feasibility and ensuring core functionality delivery.
-        
-        Key Guidelines:
-        1. Convert Time Estimates: Convert all time estimates into raw mandays:
-        - 1 week = 7 mandays
-        - 1 month = 28-31 mandays
-        - If input is in days, use as is.
-        - If input is a range (e.g., 1-2 weeks), use the average (1.5 weeks = 7.5 mandays).
-        2. **Preserve All Components:** Do not remove any components from the list, even if they are low priority.
-        3. **Adjust Mandays Based on Priority:**
-        - For **high priority components**, allocate the majority of mandays (eg: 1-3) to ensure critical functionalities are minimally viable. However , components such as authentication , security , etc. can be set to 0.
-        - For **medium priority components**, allocate minimal mandays (eg: 1-2) or set them to 0, as these can be deferred without impacting core functionalities.
-        - For **low priority components**, set mandays to 0, as these are not essential for the MVP.
-        4.  Retain Planning/Testing Components: All identified planning and testing components must be retained in the list but have their mandays set to 0. Do not remove them.
-        5. **Iterative Adjustment:** If the total mandays for the development components still exceed the MVP timeline after the first adjustment, further reduce or set the mandays to 0 on high and medium priority components if necessary until the total fits within the timeline.
-        - **MVP Timeline Constraint:** Ensure the final total mandays do not exceed the MVP timeline.
-        6. Justify Adjustments: Provide a brief explanation for any adjustments made to the mandays, ensuring they align with the timeline and maintain the MVP's core functionality.
-        
-        Output Format Requirements:
-        - Provide a revised list of development components with updated mandays estimates.
-        - Include the "Priority" column for reference.
-        - Include the total mandays for the revised plan and confirm whether it fits within the MVP timeline.
-        - Ensure the output is concise and actionable.
-        
-        Important Notes:
-        - If the total mandays still exceed the timeline after adjustments, prioritize further reductions in medium priority components while keeping high priority components as intact as possible.
-        - Do not remove any components from the list, even if their mandays are reduced to 0.
-        """,
-        inputs=["identified_priority_components", "generated_prd"],
-        outputs=["revised_mandays_estimates"],
-        model=ModelType.O1_MINI,
-        description="Step 2.3 : Recalculate Mandays",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.3 : Recalculate MVP Mandays",
-        ui={
-            "mandays_recalculation_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Mandays Recalculation Prompt",
-                lines=20,
-                interactive=True
-            )
-        }
-    ),
-
-    "generate_MVP_mandays": PromptConfig(
-        prompt=
-        """
-        Using the revised mandays estimates from the previous step, format the output into two clearly separated CSV sections: one for Planning/Testing  Components and another for Development  Components.
-        
-        Objective:
-        Structure the output to clearly delineate the two sections while maintaining the original column structure.
-        
-        Output Format Requirements:
-        - First Section - Planning & Testing Components:
-        component,mandays,description
-        "Requirements Analysis",0,"Critical user requirements and system specifications"
-        
-        - Second Section - Development Components:
-        component,subcomponent,mandays,description
-        "Backend","Core API Development",3,"Essential API endpoints for basic functionality"
-        
-        Important:
-        - Each section must maintain its original column structure.
-        - Sections MUST be separated by the marker: "---SECTION BREAK---".
-        - Include ALL components and NOT change anything.
-        - No empty rows or missing values.
-        - Text values must be in double quotes.
-        - Numbers must not be in quotes.
-        
-        Return only the CSV content with the section break, no additional text or explanations.
-        """,
-        inputs=["revised_mandays_estimates"],
-        outputs=["generated_MVP_mandays"],
-        model=ModelType.O1_MINI,
-        description="Step 2.3 : Generate MVP Mandays",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.3 : Recalculate MVP Mandays",
-        ui={
-            "generated_MVP_mandays_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="MVP Mandays Formatting System Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_MVP_mandays_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="Formatted MVP Mandays",
-                interactive=True,
-            )
-        }
-    ),
-}
-  

prompt_configs.py

@@ -39,6 +39,100 @@ class PromptConfig:
 #################################################################################################################################################
 
 PROMPTS = {
+    "component_agent": PromptConfig(
+        prompt=
+        """
+        You are an AI that analyzes a software project’s requirements and determines all possible valid and unique configurations based on the provided constraints.
+        
+        Input Data:
+        
+        - Project Requirement Document (PRD) – Describes the project’s goals and scope.
+        - List of Functions – A predefined set of function names and descriptions. STRICTLY use these ONLY (do not create new functions).
+        
+        Objective:
+        Identify and classify valid project configurations into one of the following categories:
+        
+        - Hybrid Configurations – If the project requires both chatbot and document extraction functionalities.
+        - Chatbot-Only Configurations – If the project is focused solely on chatbot functionality.
+        - Document Extraction-Only Configurations – If the project involves document extraction but does not require chatbot features.
+        
+        Rules for Ensuring Uniqueness:
+        
+        - Each configuration must belong to only one category (Chatbot, Document Extraction, or Hybrid) and be sorted by best match to the project requirements.
+        - Avoid redundant permutations – Ensure no duplicate function combinations under different names.
+        - Do NOT create new functions – Use only those from the provided function list.
+        
+        Expected Output Format:
+        
+        - A structured JSON object with no duplicate function combinations.
+        - DO NOT include any code guards or placeholders.
+        
+        Example 1:
+        Project Requirement:
+        "The system must provide a chatbot to handle customer queries. It should support intent recognition and predefined workflows. The chatbot must work across web, mobile, and messaging platforms and escalate complex queries to human agents when needed."
+        
+        OUTPUT:
+        [
+        {
+        "configuration_type": "Basic Chatbot",
+        "selected_functions": [
+        "generate_plan_test_components",
+        "generate_intent_list",
+        "generate_engage_dev_components"
+        ]
+        }
+        ]
+        
+        Example 2:
+        Project Requirement:
+        "The system must extract structured data from PDFs. It should identify key fields, validate extracted data, support batch processing, and integrate with our existing software."
+        
+        OUTPUT:
+        [
+        {
+        "configuration_type": "Basic Document Extraction",
+        "selected_functions": [
+        "generate_plan_test_components",
+        "generate_page_dev_components"
+        ]
+        }
+        ]
+        
+        Example 3:
+        Project Requirement:
+        "The system must integrate a chatbot with document extraction. The chatbot should accept user-uploaded documents, extract relevant data, and respond based on extracted content."
+        
+        OUTPUT:
+        [
+        {
+        "configuration_type": "Basic Chatbot and Document Extraction",
+        "selected_functions": [
+        "generate_plan_test_components",
+        "generate_intent_list",
+        "generate_page_dev_components",
+        "generate_engage_dev_components"
+        ]
+        }
+        ]
+        
+        <List of Functions: ONLY use these>
+        generate_plan_test_components: For ALL projects, generates a granular component list for the Planning and Testing phases,while explicitly excluding development-related tasks.
+        
+        generate_page_dev_components: For document extraction projects, produces a structured development component breakdown, categorizing frontend, backend, and integration tasks, while addressing edge cases and special considerations.
+        
+        generate_intent_list: For chatbot projects, analyzes a project’s requirements to define all possible chatbot intents and workflows, categorizing them by complexity (simple, multi-step, fallback, etc.) while also identifying overlooked but industry-relevant intents based on competitor comparisons.
+        
+        generate_engage_dev_components: For chatbot projects, extracts comprehensive development components from the Project Requirement Document (PRD) and Chatbot Intent List (CIL), translating intents, workflows, and fallback scenarios into specific technical deliverables for structured implementation.
+        
+        <Requirements>
+        """,
+        inputs=['generated_prd'],
+        outputs=["configuration_type"],
+        step="Analyze Configuration Type",
+        model=ModelType.O1_MINI,
+        description="Component Agent",
+    ),
+    
     "client_initial_question": PromptConfig(
         prompt=
         """
@@ -115,7 +209,7 @@ PROMPTS = {
         inputs=["project_detail"],
         outputs=["follow_up_questions"],
         model=ModelType.O1_MINI,
-        description="Generate follow-up questions with sample answers",
+        description="Generate Client Follow Up Questions",
         step="Chatbot Prompt Editors",
         ui={
             "client_follow_up_prompt_editor": UIConfig(
@@ -152,14 +246,14 @@ PROMPTS = {
         Just return the string text and NOTHING else, omit code guards.
         """,
         inputs=["project_detail", "requirements_rubric"],
-        outputs=["generated_questions"],
+        outputs=["generated_engage_follow_up_questions"],
         model=ModelType.O1_MINI,
-        description="Generate detailed questions with sample answers",
+        description="Generate Engage Context-Aware List Of Questions",
         step="Chatbot Prompt Editors",
         ui={
-            "question_generator_prompt_editor": UIConfig(
+            "engage_follow_up_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="Question Generator Prompt",
+                label="Engage Follow Up Questions Prompt",
                 lines=20,
                 interactive=True,
             )
@@ -215,14 +309,14 @@ PROMPTS = {
           Only provide the list of formatted questions without any additional introduction or summary.
         """,
         inputs=['project_detail'],
-        outputs=['gathered_project_input'],
+        outputs=['generated_page_follow_up_questions'],
         model=ModelType.O1_MINI,
-        description="Generate Context-Aware List Of Questions",
+        description="Generate Page Context-Aware List Of Questions",
         step="Chatbot Prompt Editors",
         ui={
-            "gather_project_input_prompt_editor": UIConfig(
+            "page_follow_up_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="Gather Project Input Prompt",
+                label="Page Follow Up Questions Prompt",
                 lines=20,
                 interactive=True
             )
@@ -250,14 +344,14 @@ PROMPTS = {
         Just return the generated list of follow up questions as string and nothing else.
         """,
         inputs=["project_detail"],
-        outputs=["generated_follow_up_questions"],
+        outputs=["generated_engage_further_follow_up_questions"],
         model=ModelType.O1_MINI,
-        description="Generate detailed follow up questions with sample answers",
+        description="Generate Engage Further Follow Up Questions",
         step="Chatbot Prompt Editors",
         ui={
-            "follow_up_prompt_editor": UIConfig(
+            "engage_further_follow_up_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="Folow-up Questions Prompt",
+                label="Engage Further Follow Up Questions Prompt",
                 lines=20,
                 interactive=True
             )
@@ -280,20 +374,21 @@ PROMPTS = {
         Just return the formatted list as string and nothing else. 
         """,
         inputs=['project_detail'],
-        outputs=['reviewed_project_input'],
+        outputs=['generated_page_further_follow_up_questions'],
         model=ModelType.O1_MINI,
-        description="Review project input",
+        description="Generate Page Further Follow Up Questions",
         step="Chatbot Prompt Editors",
         ui={
-            "review_project_input_prompt_editor": UIConfig(
+            "page_further_follow_up_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="Review Project Input Prompt",
+                label="Page Further Follow Up Questions Prompt",
                 lines=20,
                 interactive=True
             )
         }
     ),
     
+    #########################################################################################
     "generate_prd": PromptConfig(
         prompt=
         """
@@ -303,11 +398,18 @@ PROMPTS = {
         Do not also exclude any input provided.
         Structure the document to ensure clarity and logical flow.
         Make sure to make the title "Project Requirements".
+        
+        Return a JSON object with TWO keys, in the following structure:
+        
+        {
+        "detailed_breakdown": "A well-structured, logically ordered breakdown of the input, ensuring clarity while preserving all details.",
+        "summary": "A concise summary capturing key points, timeline, budget constraints, and objectives."
+        }
         """,
         inputs=["project_detail"],
         outputs=["generated_prd"],
         model=ModelType.O1_MINI,
-        description="Step 1.1 : Generate Project Requirements Document (PRD)",
+        description="Generate Project Requirements Document (PRD)",
         step="Step 1 : Scope & Components",
         ui={
             "requirement_prompt_editor": UIConfig(
@@ -360,7 +462,7 @@ PROMPTS = {
         inputs=["generated_prd"],
         outputs=["generated_intent_list"],
         model=ModelType.O1_MINI,
-        description="Step 1.2 : Generate Intent List",
+        description="Generate Intent List",
         step="Step 1 : Scope & Components",
         ui={
             "intent_list_prompt_editor": UIConfig(
@@ -384,7 +486,7 @@ PROMPTS = {
         }
     ),
     
-    "generate_page_plan_test_components": PromptConfig(
+    "generate_plan_test_components": PromptConfig(
         prompt=
         """
         Context:
@@ -399,6 +501,11 @@ PROMPTS = {
         For each phase, include project-specific components that align with the goal of developing the software Project. Break down each phase into granular sub-components, ensuring specificity and alignment with the PRD.
         Use the PRD to extract relevant, granular components that reflect deliverables unique to this project.
         
+        Tech Stack:
+        Backend: FastAPI, Python
+        Chatbot: Chatbot Builder , COZE , Yellow.ai
+        Infrastructure: AWS, PostgreSQL, Redis, Docker, Alembic
+        
         Output Format:
         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.
@@ -406,7 +513,7 @@ PROMPTS = {
         inputs=["generated_prd"],
         outputs=["generated_plan_test_components"],
         model=ModelType.O1_MINI,
-        description="Step 1.2 : Generate planning and testing components",
+        description="Generate planning and testing components",
         step="Step 1 : Scope & Components",
         ui={
             "plan_test_component_prompt_editor": UIConfig(
@@ -430,6 +537,7 @@ PROMPTS = {
         }
     ),
 
+    #IGNORE FIRST
     "generate_engage_plan_test_components": PromptConfig(
         prompt=
         """
@@ -460,7 +568,7 @@ PROMPTS = {
         inputs=["generated_prd"],
         outputs=["generated_plan_test_components"],
         model=ModelType.O1_MINI,
-        description="Step 1.3 : Generate planning and testing components",
+        description="Generate planning and testing components",
         step="Step 1 : Scope & Components",
         ui={
             "plan_test_prompt_editor": UIConfig(
@@ -528,7 +636,7 @@ PROMPTS = {
         inputs=["generated_prd"],
         outputs=["generated_dev_components"],
         model=ModelType.O1_MINI,
-        description="Step 1.3 : Generate development components",
+        description="Generate development components",
         step="Step 1 : Scope & Components",
         ui={
             "dev_component_prompt_editor": UIConfig(
@@ -620,7 +728,7 @@ PROMPTS = {
         inputs=["generated_prd" , "generated_intent_list"],
         outputs=["generated_dev_components"],
         model=ModelType.O1_MINI,
-        description="Step 1.4 : Generate development components",
+        description="Generate development components",
         step="Step 1 : Scope & Components",
         ui={
             "dev_component_prompt_editor": UIConfig(
@@ -686,7 +794,7 @@ PROMPTS = {
         inputs=["generated_dev_components"],
         outputs=["reformatted_dev_components"],
         model=ModelType.O1_MINI,
-        description="Step 1.4 : Reformat development components",
+        description="Reformat development components",
         step="Step 1 : Scope & Components",
         ui={
             "reformatted_dev_components_prompt_editor": UIConfig(
@@ -766,7 +874,7 @@ PROMPTS = {
         inputs=["generated_dev_components"],
         outputs=["reformatted_dev_components"],
         model=ModelType.O1_MINI,
-        description="Step 1.5 : Reformat development components",
+        description="Reformat development components",
         step="Step 1 : Scope & Components",
         ui={
             "reformatted_dev_components_prompt_editor": UIConfig(