- Change to having 1 prompt executor

- Deleted v3_functions
- Created a complete config file
This is phase 2. This is working. However , everything still does not dynamically change if config file were to change.

Project.py

@@ -1,11 +1,12 @@
-from enum import Enum
-# from ProjectClient import Client,zus_coffee,ssm, game
-# from prompts import * #engage
+from common_functions_v4 import *
+from page_prompts_config import *
 from page_prompts_v3 import *
 from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
 import openai
 from contextlib import contextmanager
-# import json
+import json
+from state import state
+
 
 @contextmanager
 def openai_session():
@@ -64,323 +65,295 @@ def call_4o_mini(prompt):
         
         except Exception as e:
             return f"Error generating output: {str(e)}"
-
-class ProjectType(Enum):
-    Page = "Page"
-    Sage = "Sage"
-    Engage = "Engage"
-
-class Project:
-    def __init__(self, project_type: ProjectType, session_id = None):
+        
+class Project :
+    def __init__(self, project_type, session_id = None):
         self.project_type = project_type
         self.session_id = session_id 
-        # requirement_rubric, fetch from db
-        # then retrive from here again, omit recalls to fetch the same thing over and over
-        self.project_detail = []
-        self.generated_prd = ""
-        
-        #v1 - cant delete cause it breaks things
-        self.rubric = [] 
-        self.rubric_section_names = []
-        self.component_list = []
-        self.component_csv = ""
-        self.flared_csv = ""
-
-        # Method 3 - Top Down Approach Variables
-        # Further break things down based on phases 
-        # Plan & Test , Dev
-        self.derived_plan_test_components = ""
-        self.derived_dev_components = ""
-        self.derived_plan_test_tasks = ""
-        self.derived_dev_tasks = ""
-        self.derived_baseunits = ""
-        self.derived_mandays = ""
-
-        self.quotation_cost = ""
-
-    def reset_project(self):
-        self.project_detail = []
-        self.generated_prd = ""
-
-        #v1 - cant delete cause it breaks things
         self.rubric = [] 
         self.rubric_section_names = []
         self.component_list = []
         self.component_csv = ""
         self.flared_csv = ""
-
-        # Method 3 - Top Down Approach Variables
-        # Further break things down based on phases 
-        # Plan & Test , Dev
-        self.derived_plan_test_components = ""
-        self.derived_dev_components = ""
-        self.derived_plan_test_tasks = ""
-        self.derived_dev_tasks = ""
-        self.derived_baseunits = ""
-        self.derived_mandays = ""
-
-        self.quotation_cost = ""
-
-        print("Successfully reser project variables")
-
-
-    def set_rubric(self,rubric):
-        self.rubric = rubric
-
-    def set_component_csv(self,component_csv):
-        self.component_csv = component_csv
-    
-    def is_active(self):
-        return self.session_id != None
-    
-    def get_component_csv(self):
-        return self.component_csv
-
-    def set_component_list(self,component_list):
-        self.component_list = component_list
-
-    def set_rubric_section_names(self,rubric_section_names):
-        self.rubric_section_names = rubric_section_names
-
-    def set_project_detail(self,project_detail):
-        self.project_detail = project_detail
-
-    def add_project_detail(self,project_detail):
-        self.project_detail.append(project_detail)
-
-    def get_project_detail(self):
-        return(self.project_detail)
-    
-    # the rubric to generate project question
-    def project_question_generation_rubric(self ):
-        headers = [ 'Criteria', 'Initial Questions', 'Quantifiable Value']
-        # table = '| ' + ' | '.join(headers) + ' |'
-        table = ' | '.join(headers) 
-        # table += '\n' + '| ' + ' | '.join(['---'] * len(headers)) + ' |'
+        self.project_detail = [] 
         
-        # print(len(self.rubric))
-        for entry in self.rubric:
-            # print(entry)
-            # table += f"\n{entry['criteria']} | {entry['explanation']} | {entry['priority']} | {entry['quantifiable_value'] or ''}"
-            table += f"\n{entry['criteria']} | {entry['initial_question']} | {entry['quantifiable_value'] or ''}"
-            # table += f"\n| {entry['section_name']} | {entry['criteria']} | {entry['explanation']} | {entry['priority']} | {entry['quantifiable_value'] or ''} |"
-        return table
-    
-    # the rubric to grade answers project questions
-    def project_question_grading_rubric(self):
-        headers = ['Criteria', 'Explanation', 'Priority', 'Quantifiable Value']
-        # headers = ['Criteria', 'Explanation', 'Priority', 'Quantifiable Value']
-        # table = '| ' + ' | '.join(headers) + ' |'
-        table = ' | '.join(headers) 
-        # table += '\n' + '| ' + ' | '.join(['---'] * len(headers)) + ' |'
+        for config in PROMPTS.values():
+            for output in config.outputs:
+                setattr(self, output, "")
+
+    INPUT_MAPPINGS = {
+        'project_detail': lambda self: self.get_project_detail(),
+        'generated_prd': lambda self: self.generated_prd,
+        'component_list': lambda self: self.component_list,
+        'derived_plan_test_components': lambda self: self.derived_plan_test_components,
+        'derived_dev_components': lambda self: self.derived_dev_components,
+        'quotation_cost': lambda self: self.quotation_cost,
+        'derived_tasks': lambda self: self.derived_tasks,
+        'flared_csv': lambda self: self.flared_csv,
+        'component_to_text': lambda self: self.component_to_text,
+        'quotation_details': lambda self: self.quotation_details,
+        'quotation_table': lambda self: self.quotation_table
+    }
+
+    def execute_prompt(self, prompt_name: str, input_variables: Dict[str, Any]) -> str:
+        """Execute a prompt with given input variables
         
-        # print(len(self.rubric))
-        for entry in self.rubric:
-            # print(entry)
-            # table += f"\n{entry['criteria']} | {entry['explanation']} | {entry['priority']} | {entry['quantifiable_value'] or ''}"
-            table += f"\n{entry['criteria']} | {entry['explanation']} | {entry['priority']} | {entry['quantifiable_value'] or ''}"
-            # table += f"\n| {entry['section_name']} | {entry['criteria']} | {entry['explanation']} | {entry['priority']} | {entry['quantifiable_value'] or ''} |"
-        return table
-
-    # different pemutation of columns, to reduce token count
-    def rubric_to_text(self):
-        headers = ['Section Name', 'Criteria', 'Explanation', 'Priority', 'Quantifiable Value']
-        # headers = ['Criteria', 'Explanation', 'Priority', 'Quantifiable Value']
-        # table = '| ' + ' | '.join(headers) + ' |'
-        table = ' | '.join(headers) 
-        # table += '\n' + '| ' + ' | '.join(['---'] * len(headers)) + ' |'
+        Args:
+            prompt_name: Name of the prompt config to use from PROMPTS
+            input_variables: Dictionary of input variables matching the prompt's required inputs
         
-        # print(len(self.rubric))
-        for entry in self.rubric:
-            # print(entry)
-            # table += f"\n{entry['criteria']} | {entry['explanation']} | {entry['priority']} | {entry['quantifiable_value'] or ''}"
-            table += f"\n{entry['section_name']} | {entry['criteria']} | {entry['explanation']} | {entry['priority']} | {entry['quantifiable_value'] or ''}"
-            # table += f"\n| {entry['section_name']} | {entry['criteria']} | {entry['explanation']} | {entry['priority']} | {entry['quantifiable_value'] or ''} |"
-        return table
-    
-    def rubric_to_verify(self):
-        # headers = ['Section Name', 'Criteria', 'Explanation', "Priority"]
-        headers = ['Criteria', 'Explanation', "Priority"]
-        # table = '| ' + ' | '.join(headers) + ' |'
-        table = ' | '.join(headers) 
-        # table += '\n' + '| ' + ' | '.join(['---'] * len(headers)) + ' |'
+        Returns:
+            str: Generated output from the model
+        """
+        if prompt_name not in PROMPTS:
+            raise ValueError(f"Unknown prompt: {prompt_name}")
         
-        # print(len(self.rubric))
-        for entry in self.rubric:
-            merged_columns = entry['explanation'] + " " + (entry['quantifiable_value'] or '')
-            # print(entry)
-            table += f"\n {entry['criteria']} | {merged_columns} | {entry['priority']}"
-            # table += f"\n| {entry['section_name']} | {entry['criteria']} | {entry['explanation']} | {entry['priority']} | {entry['quantifiable_value'] or ''} |"
-        return table
-    
-    def component_to_text(self):
-        # If input is empty, return empty string
-        if not self.component_list:
-            return ""
+        config = PROMPTS[prompt_name]
         
-        # Get headers from the first row
-        # headers = list(self.component_list[0].keys())
-        headers = ["base_project_name", "module", "submodule","unit_type", "quantity"]
-        # Create header row
-        table = " | ".join(headers) + "\n"
-        table += "-" * len(table) + "\n"
+        # Validate all required inputs are provided
+        missing_inputs = set(config.inputs) - set(input_variables.keys())
+        if missing_inputs:
+            raise ValueError(f"Missing required inputs for {prompt_name}: {missing_inputs}")
         
-        # Add data rows
-        for row in self.component_list:
-                # Convert None values to empty strings and all values to strings
-            values = [str(row[header]) if row[header] is not None else "" for header in headers]
-            table += " | ".join(values) + "\n"
-    
-        return table
-
-
-    #Functions that generates based on prompts
-    def generate_client_follow_up(self ,system_prompt = client_follow_up_with_sample_answers):
-        # current_form = self.filter_non_empty_answer()
+        # Build prompt by formatting with provided variables
         prompt = f"""
-        {system_prompt}
-
-        # Input:
-        ## Client Details / Project Requirement Q&A
-        {self.project_detail}
+        {config.prompt}
+        
+        {' '.join([f'# {key}:\n{input_variables[key]}\n' for key in config.inputs])}
         """
-
-
-        # print(f"\n\generate_client_follow_up with prompt: {prompt}\n\n")
-        result = call_o1_mini(prompt)
-        # print(f"type, result : {type(result)}, {result}")
-
-        return result
-    
-    def rewrite_qa(self,system_prompt = structure_qa):
-        prompt = f"""
-        {system_prompt}
-
-        # Input:
-        ## Client Details / Project Requirement Q&A
-        {self.get_project_detail()}"""
-
-        result = call_o1_mini(prompt)
-        self.generated_prd = result
-        # print(f"POPULATED TABLE : {result}")
+        
+        # Call appropriate model based on config
+        result = (
+            call_4o_mini(prompt) 
+            if config.model == ModelType.O4_MINI 
+            else call_o1_mini(prompt)
+        )
+        
+        # Store outputs in project attributes if specified
+        for output in config.outputs:
+            if hasattr(self, output):
+                setattr(self, output, result)
+        
         return result
 
+#Functions to interact with common_functions_v4.py#
+    def set_rubric(self, rubric_list):
+        """Set the rubric for the project"""
+        self.rubric = rubric_list
 
-    def generate_components(self, system_prompt = define_components):
-        prompt = f"""
-        {system_prompt}
-
-        # PRD :
-        {self.generated_prd}
-    
-        """
-        # print(prompt)
-        result = call_4o_mini(prompt)
-        self.derived_plan_test_components = result
-        return result 
-    
-    def generate_dev_components(self, system_prompt = define_dev_components):
-        prompt = f"""
-        {system_prompt}
-
-        # PRD :
-        {self.generated_prd}
-        """
-
-        # print(prompt)
-        result = call_o1_mini(prompt)
-
-        # need to check whether this would work
-        self.derived_dev_components = result
-        return result 
-    
-    
-    def generate_plan_test_mandays(self, component_list, system_prompt = derive_plan_test_mandays):
-        prompt = f"""
-        {system_prompt}
-
-        # Component List
-        {component_list}
-
-        """
+    def set_rubric_section_names(self, section_names):
+        """Set the rubric section names for the project"""
+        self.rubric_section_names = section_names
 
-        # print(prompt)
-        result = call_o1_mini(prompt)
-        # self.derived_mandays = result
-        return result 
-    
-    def generate_dev_mandays(self, component_list, system_prompt = derive_dev_mandays):
-        prompt = f"""
-        {system_prompt}
+    def set_component_list(self, component_list):
+        """Set the component list for the project"""
+        self.component_list = component_list
 
-        # Component List
-        {component_list}
+    def get_project_detail(self):
+        """Get the project details as a formatted string"""
+        return "\n".join(self.project_detail) if self.project_detail else ""
 
-        """
+    def add_project_detail(self, detail):
+        """Add a new project detail"""
+        if detail:
+            self.project_detail.append(detail)
 
-        # print(prompt)
-        result = call_o1_mini(prompt)
-        # self.derived_mandays = result
-        return result 
+    def reset_project(self):
+        """Reset all project attributes"""
+        for config in PROMPTS.values():
+            for output in config.outputs:
+                setattr(self, output, "")
+
+    def generate_client_follow_up(self) -> str:
+        """Generate follow-up questions after initial client response"""
+        return self.execute_prompt(
+            "generate_client_follow_up",
+            {
+                "project_detail": self.get_project_detail()
+            }
+        )
+
+    def gather_project_input(self) -> str:
+        """Generate context-aware questions to gather project requirements"""
+        return self.execute_prompt(
+            "gather_project_input",
+            {
+                "project_detail": self.get_project_detail()
+            }
+        )
+
+    def review_project_input(self) -> str:
+        """Review project input and generate follow-up questions to address gaps"""
+        return self.execute_prompt(
+            "review_project_input",
+            {
+                "project_detail": self.get_project_detail()
+            }
+        )
+
+#Functions to interact with the frontend#
+def v4_generate_prd_and_components(progress=gr.Progress()):
+    # Step 1: Rewrite QA
+    progress(0, desc="Progress 1: Generating PRD from Q&A...")
+    generated_prd = state.quotation_project.execute_prompt(
+        "rewrite_qa",
+        {
+            "project_detail": state.quotation_project.get_project_detail()
+        }
+    )
     
-    def gather_project_input(self, system_prompt = gather_project_input_prompt):
-        prompt = f"""
-        {system_prompt}
-
-        # Client Background:
-        {self.get_project_detail()}
+    # Step 2: Generate Components
+    progress(0.4, desc="Progress 2: Generating Planning & Testing Component...")
+    plan_test_component_list = state.quotation_project.execute_prompt(
+        "generate_components",
+        {
+            "generated_prd": state.quotation_project.generated_prd
+        }
+    )
+
+    progress(0.7, desc="Progress 3: Generating Development Components...")
+    dev_component_list = state.quotation_project.execute_prompt(
+        "generate_dev_components",
+        {
+            "generated_prd": state.quotation_project.generated_prd
+        }
+    )
+
+    progress(1.0, desc="Complete!")
+    return [
+        generated_prd,
+        plan_test_component_list,
+        dev_component_list,
+        dev_component_list,
+        "Generated PRD and Component List! Click Generate Final Quotation To Generate Quotation"
+    ]
+
+def v4_generate_quotation(updated_plan_test_component, updated_dev_component, progress=gr.Progress()):
+    state.quotation_project.derived_plan_test_components = updated_plan_test_component
+    state.quotation_project.derived_dev_components = updated_dev_component
     
-        """
-        print(prompt)
-        result = call_o1_mini(prompt)
-        return result
+    # Generate mandays for plan & test components
+    progress(0.5, desc="Progress 1: Deriving Mandays for Plan & Test Components...")
+    plan_test_mandays = state.quotation_project.execute_prompt(
+        "generate_plan_test_mandays",
+        {
+            "component_list": updated_plan_test_component
+        }
+    )
+
+    # Generate mandays for dev components
+    progress(0.7, desc="Progress 2: Deriving Mandays for Dev Components...")
+    dev_mandays = state.quotation_project.execute_prompt(
+        "generate_dev_mandays",
+        {
+            "component_list": updated_dev_component
+        }
+    )
+
+    # Process results
+    plan_test_df = pd.read_csv(StringIO(plan_test_mandays), on_bad_lines='skip')
+    dev_df = pd.read_csv(StringIO(dev_mandays), on_bad_lines='skip')
+
+    plan_test_df['mandays'] = pd.to_numeric(plan_test_df['mandays'].replace('', '0'), errors='coerce').fillna(0)
+    dev_df['mandays'] = pd.to_numeric(dev_df['mandays'].replace('', '0'), errors='coerce').fillna(0)
     
-    def review_project_input(self, system_prompt = review_project_input_prompt):
-        prompt = f"""
-        {system_prompt}
+    total_mandays, total_cost, estimated_months = calculate_mandays_and_costs(plan_test_df, dev_df)
 
-        # Client Background:
-        {self.get_project_detail()}
-    
+    progress(1.0, desc="Complete!")
+    cost_summary = f"""
+        Total Mandays: {total_mandays:.2f} 
+        Total Cost: ${total_cost:,.2f}
+        ({estimated_months:.2}months)
         """
+    return [plan_test_df, dev_df, "Generated Quotation!", cost_summary]
+
+def v4_generate_sow(generated_prd, plan_test_component, dev_component, cost, progress=gr.Progress()):
+    state.quotation_project.derived_plan_test_components = plan_test_component
+    state.quotation_project.derived_dev_components = dev_component
+    state.quotation_project.quotation_cost = cost
+
+    # Generate general SOW
+    progress(0.4, desc="Progress 1: Drafting SOW")
+    general_sow = state.quotation_project.execute_prompt(
+        "generate_BD_SOW",
+        {
+            "generated_prd": generated_prd,
+            "derived_plan_test_components": plan_test_component,
+            "derived_dev_components": dev_component,
+            "quotation_cost": cost
+        }
+    )
+
+    # Generate detailed SOW
+    progress(0.8, desc="Progress 2: Drafting Technical SOW")
+    detailed_sow_json = state.quotation_project.execute_prompt(
+        "generate_Tech_SOW",
+        {
+            "derived_plan_test_components": plan_test_component,
+            "derived_dev_components": dev_component
+        }
+    )
 
-        print(prompt)
-        result = call_o1_mini(prompt)
-        return result
+    try:
+        # Parse detailed_sow into a JSON object
+        detailed_sow_json = json.loads(detailed_sow_json)
+
+        # Extract required fields
+        scope_summary = detailed_sow_json.get("scope_summary", "")
+        modules_and_functional_requirements = detailed_sow_json.get("modules_and_functional_requirements", "")
+        out_of_scope = detailed_sow_json.get("out_of_scope", "")
+        system_flow = detailed_sow_json.get("system_flow", "")
+
+        # Combine all fields into detailed_sow
+        detailed_sow = f"{scope_summary}\n\n{modules_and_functional_requirements}\n\n{out_of_scope}\n\n{system_flow}"
+
+        # Create final SOW
+        final_general_sow = f"**Hi , some sections of this SOW is generated seprately from the main draft. youll have to move this to the right spot manually ;)\n **Project Quotation:**\n{cost}\n{modules_and_functional_requirements}\n\n {general_sow}\nEOF"
+        return [final_general_sow, detailed_sow, "Generated SOW!"]
+    except Exception as e:
+        return ["Error generating SOW", "Error: " + str(e), "Failed to generate SOW"]
+
+def v4_recalculate_cost(plan_test_df, dev_df):
+    """Recalculate costs based on modified dataframe values"""
+    try:
+        # Convert mandays columns to numeric, replacing empty values with 0
+        plan_test_df['mandays'] = pd.to_numeric(plan_test_df['mandays'].replace('', '0'), errors='coerce').fillna(0)
+        dev_df['mandays'] = pd.to_numeric(dev_df['mandays'].replace('', '0'), errors='coerce').fillna(0)
     
-    def generate_general_sow(self, system_prompt = sow_general):
-        prompt = f"""
-        {system_prompt}
-
-        # Quotation: 
-        {self.quotation_cost}
+        # Calculate totals
+        total_mandays, total_cost, estimated_months = calculate_mandays_and_costs(plan_test_df, dev_df)
 
-        # Project Requirements Doc:
-        {self.generated_prd}
-
-        # Components:
-        {self.derived_plan_test_components}
-
-        {self.derived_dev_components}
+        cost_summary = f"""
+        Total Mandays: {total_mandays:.2f}
+        Total Cost: ${total_cost:,.2f}
+        ({estimated_months:.2}months)
         """
+        return f"Successfully Updated Quotation. SessionID:{state.quotation_project.session_id}", cost_summary
+    except Exception as e:
+        return f"Error recalculating costs: {str(e)}", f"Error recalculating costs: {str(e)}"
 
-        print(prompt)
-        result = call_o1_mini(prompt)
-        return result
-    
-    def generate_sow_details(self, system_prompt = sow_detailed):
-        prompt = f"""
-        {system_prompt}
-
-        # Components:
-        {self.derived_plan_test_components}
 
-        {self.derived_dev_components}
+def update_display_mode(mode, content):
+    if mode == "Textbox":
+        return gr.update(visible=True, value=content), gr.update(visible=False, value=content)
+    else:
+        return gr.update(visible=False, value=content), gr.update(visible=True, value=content)
     
-        """
+def update_system_prompts(requirement_prompt, plan_test_prompt, dev_prompt, 
+                         plantest_mandays_prompt, dev_mandays_prompt,
+                         bd_sow_prompt, tech_sow_prompt):
+    """Update system prompts when edited by user"""
+    try:
+        # Update prompts in config
+        PROMPTS["rewrite_qa"].prompt = requirement_prompt
+        PROMPTS["generate_components"].prompt = plan_test_prompt
+        PROMPTS["generate_dev_components"].prompt = dev_prompt
+        PROMPTS["generate_plan_test_mandays"].prompt = plantest_mandays_prompt
+        PROMPTS["generate_dev_mandays"].prompt = dev_mandays_prompt
+        PROMPTS["generate_BD_SOW"].prompt = bd_sow_prompt
+        PROMPTS["generate_Tech_SOW"].prompt = tech_sow_prompt
+
+        return "✅ System prompts updated successfully"
+    except Exception as e:
+        return f"❌ Error updating prompts: {str(e)}"
 
-        print(prompt)
-        result = call_o1_mini(prompt)
-        return result
-    
-    

app.py

@@ -1,7 +1,9 @@
 import gradio as gr
-from v3_functions import *
+from Project import *
+from common_functions_v4 import *
 from google_drive import * 
 from notion import *
+from state import state
 
 with open("page_main.css", "r") as file:
     custom_css = file.read()
@@ -284,7 +286,7 @@ with gr.Blocks(title="v3 Page Quotation Chatbot (with SOW)" , css=custom_css) as
 
                     #Update Prompts Btn
                     save_prompts_btn.click(
-                        fn=update_system_prompts,
+                       fn=update_system_prompts,
                         inputs=[
                              requirement_prompt_editor,
                              plan_text_prompt_editor,
@@ -329,31 +331,27 @@ with gr.Blocks(title="v3 Page Quotation Chatbot (with SOW)" , css=custom_css) as
                     
                     #Generate PRD & Components
                     page_generate_prd_btn.click(
-                        fn=v3_generate_prd_and_components, 
+                        fn=v4_generate_prd_and_components, 
                         outputs=[page_prd_box_v3_text,page_plan_test_component_table_v3_text,page_dev_component_table_v3_text,page_dev_component_table_v3_markdown,page_progress_update]
                     )
 
                     #Recalculate Cost
                     page_recalc_btn.click(
-                    fn=v3_recalculate_cost, 
+                    fn=v4_recalculate_cost, 
                     inputs=[page_plan_test_mandays_v3,page_dev_mandays_v3],
                     outputs=[page_progress_update, page_units_output]
                     )
 
                     #Generate Quotation 
                     page_generate_quotation_btn.click(
-                        fn=v3_generate_quotation, 
+                        fn=v4_generate_quotation, 
                         inputs=[page_plan_test_component_table_v3_text,page_dev_component_table_v3_text],
                         outputs=[page_plan_test_mandays_v3,page_dev_mandays_v3,page_progress_update,page_units_output]
                     )
 
-                    page_save_quotation_btn.click(
-                       
-                    )
-
                     #Generate SOW
                     page_generate_sow_btn.click(
-                        fn=v3_generate_sow, 
+                        fn=v4_generate_sow, 
                         inputs=[page_prd_box_v3_text,page_plan_test_component_table_v3_text,page_dev_component_table_v3_text,page_units_output],
                         outputs=[page_general_sow_text,page_detailed_sow_text,page_progress_update]
                     )
@@ -403,6 +401,9 @@ with gr.Blocks(title="v3 Page Quotation Chatbot (with SOW)" , css=custom_css) as
                          inputs=[display_mode_tech_sow ,page_detailed_sow_text],
                          outputs=[page_detailed_sow_text , page_detailed_sow_markdown ]
                     )
+                    
+
+    
              
     # Replace single textbox with separate components
     with gr.Tab(label= "Load Project"):
@@ -450,7 +451,5 @@ with gr.Blocks(title="v3 Page Quotation Chatbot (with SOW)" , css=custom_css) as
         # outputs=[status_box, fetched_requirements_box, message_box, fetched_rubric_box, fetched_component_box]
     )
 
-
-
 if __name__ == "__main__":
     page_interface.launch(share=True)

common_functions_v3.py → common_functions_v4.py

@@ -1,4 +1,3 @@
-from Project import * 
 import pandas as pd
 from io import StringIO
 # from pathlib import Path
@@ -6,16 +5,15 @@ import psycopg2
 from psycopg2.extras import RealDictCursor
 import gradio as gr
 import datetime
-
-
-# Initialize project
-quotation_project = Project(ProjectType.Page)
-no_active_session = "**Current Session**:None"
-
+from Project import *
 import json
 import os
 from dotenv import load_dotenv
 from langtrace_python_sdk import langtrace
+from state import state 
+from page_prompts_config import PROMPTS
+
+no_active_session = "**Current Session**:None"
 
 load_dotenv()
 api_key = os.getenv("LANGTRACE_API_KEY")
@@ -26,7 +24,7 @@ langtrace.init(api_key=api_key)
 #This function is not being used 
 def check_session_exists():
     """Check if a valid session exists"""
-    return quotation_project.session_id is not None
+    return state.quotation_project.session_id is not None
 
 def get_db_connection():
     """Establishes and returns a new database connection."""
@@ -130,10 +128,10 @@ def process_response(answer, history):
         sanitized_answer = sanitize_text(str(answer))
         
         # Add the user's answer to project details
-        quotation_project.add_project_detail(sanitized_answer)
+        state.quotation_project.add_project_detail(sanitized_answer)
         
         # Update session in database if we have a session_id
-        if quotation_project.session_id:
+        if state.quotation_project.session_id:
             try:
                 conn = get_db_connection()
                 cur = conn.cursor()
@@ -143,7 +141,7 @@ def process_response(answer, history):
                     UPDATE sessions 
                     SET project_requirement = %s
                     WHERE session_id = %s
-                """, (json.dumps(quotation_project.project_detail), quotation_project.session_id))
+                """, (json.dumps(state.quotation_project.project_detail), state.quotation_project.session_id))
                 
                 conn.commit()
                 cur.close()
@@ -153,15 +151,15 @@ def process_response(answer, history):
         
         # Generate next question based on conversation stage
         if len(history) == 1:  # After first client information question
-            next_question = quotation_project.generate_client_follow_up()
+            next_question = state.quotation_project.generate_client_follow_up()
         elif len(history) == 2:  # After client follow-up
             # next_question = quotation_project.generate_questions()
-            next_question = quotation_project.gather_project_input()
+            next_question = state.quotation_project.gather_project_input()
         else:  # Subsequent project requirements questions
             # next_question = quotation_project.generate_follow_up()
-            next_question = quotation_project.review_project_input()
+            next_question = state.quotation_project.review_project_input()
         
-        # Ensure we're adding a proper tuple to history
+        # Ensure we're adding a proper tuple to hisxtory
         if isinstance(answer, str) and isinstance(next_question, str):
             history.append((answer, next_question))
         
@@ -240,10 +238,11 @@ def start_chat():
     session_id = create_new_session()
     
     # Set the rubric and session_id for the project
-
-    # Update session_id in Project instance
-    quotation_project.reset_project()
-    quotation_project.session_id = session_id
+    state.quotation_project.reset_project()
+    state.quotation_project.session_id = session_id
+    
+    # Get the initial question from prompts config
+    client_initial_question = PROMPTS["client_initial_question"].prompt
     
     initial_history = [(None, client_initial_question)]
     return client_initial_question, initial_history, f"Current Session: {session_id}"
@@ -252,18 +251,18 @@ def start_chat():
 def get_project_state():
     """Get current state of quotation_project project"""
     # Create status boxes
-    status = f"""Session ID: {quotation_project.session_id}
-    Rubric Loaded: {bool(quotation_project.rubric)}
-    Components Loaded: {bool(quotation_project.component_list)}
-    Requirements Loaded: {bool(quotation_project.project_detail)}"""
+    status = f"""Session ID: {state.quotation_project.session_id}
+    Rubric Loaded: {bool(state.quotation_project.rubric)}
+    Components Loaded: {bool(state.quotation_project.component_list)}
+    Requirements Loaded: {bool(state.quotation_project.project_detail)}"""
     
     # Format requirements as a table if they exist
     requirements_table = ""
-    if quotation_project.project_detail:
-        print(f"\n\nrequirements : {type(quotation_project.project_detail)}")
+    if state.quotation_project.project_detail:
+        print(f"\n\nrequirements : {type(state.quotation_project.project_detail)}")
         # Create markdown box for requirements
         # requirements_table = "\n\n### Project Requirements\n```markdown\n"
-        for index,requirement in enumerate(list(quotation_project.project_detail)):
+        for index,requirement in enumerate(list(state.quotation_project.project_detail)):
             requirements_table += f"\n_____________\n"
             requirements_table += f"#Requirement {index+1}\n {requirement}"
     
@@ -289,10 +288,9 @@ def fetch_session(session_id):
         print(session)
         if session:
             # 2. Update quotation_project with session data
-            quotation_project.session_id = session_id
-            
-            # Set project requirements if they exist
-            if session['project_requirement']:
+           state.quotation_project.session_id = session_id
+           
+           if session['project_requirement']:
                 try:
                     # Check if the project requirement is a string
                     if isinstance(session['project_requirement'], str):
@@ -306,22 +304,21 @@ def fetch_session(session_id):
                         requirements = session['project_requirement']
                     
                     # Clear existing details and set new ones
-                    quotation_project.project_detail = []
+                    state.quotation_project.project_detail = []
                     for requirement in requirements:
-                        quotation_project.add_project_detail(requirement.strip())  # Use strip() to remove any leading/trailing whitespace
+                        state.quotation_project.add_project_detail(requirement.strip())  # Use strip() to remove any leading/trailing whitespace
                 except Exception as e:
                     return "", "", f"Error processing project requirements in session {session_id}: {str(e)}", no_active_session
+                
+                section_name_list, rubric_list = get_section_name_and_rubric_list()
+                state.quotation_project.set_rubric(rubric_list)
+                state.quotation_project.set_rubric_section_names(section_name_list)
             
-            # 3. Fetch and set rubric
-            section_name_list, rubric_list = get_section_name_and_rubric_list()
-            quotation_project.set_rubric(rubric_list)
-            quotation_project.set_rubric_section_names(section_name_list)
-            
-            # 4. Fetch and set components
-            component_list = get_latest_components()
-            quotation_project.set_component_list(component_list)
+                # 4. Fetch and set components
+                component_list = get_latest_components()
+                state.quotation_project.set_component_list(component_list)
             
-            return (*get_project_state(), f"Successfully loaded session {session_id} with all data", f"Current Session: {session_id}")
+                return (*get_project_state(), f"Successfully loaded session {session_id} with all data", f"Current Session: {session_id}")
                     # "\n".join(rubric_list),  # Return rubric list as a string
                     # component_list)  # Ensure to extract string values
             
@@ -345,27 +342,27 @@ def insert_quotation(csv_string, total_price, total_mandays, note=None, task_bre
             SELECT COALESCE(MAX(version), 0) + 1
             FROM quotations
             WHERE session_id = %s
-        """, (quotation_project.session_id,))
+        """, (state.quotation_project.session_id,))
         
         result = cur.fetchone()
         version = result[0] if result else 1  # Default to version 1 if no result
  # Get the next version number
         total_price = float(total_price) if total_price is not None else None
         total_mandays = float(total_mandays) if total_mandays is not None else None
-        structured_details = quotation_project.generated_prd
+        structured_details = state.quotation_project.generated_prd
         
         # Convert project details to JSON string
         # Append the task table here, so we know what tasks are not in the quantity table 
         # (context : v3 function calls it slightly differently, csv_string will be the quantity table)
         # why ? lazy alter table to add new column, then create a whole new if else statement to handle this 
-        details = f"{json.dumps(quotation_project.project_detail)} + {task_breakdown_v3}" if task_breakdown_v3 else json.dumps(quotation_project.project_detail)
+        details = f"{json.dumps(state.quotation_project.project_detail)} + {task_breakdown_v3}" if task_breakdown_v3 else json.dumps(state.quotation_project.project_detail)
             
         # Insert new quotation
         cur.execute("""
             INSERT INTO quotations (session_id, version, details, quotation_csv, total_price, total_mandays,structured_details)
             VALUES (%s, %s, %s, %s, %s, %s,%s)
         """, (
-            quotation_project.session_id,
+            state.quotation_project.session_id,
             version,
             details,  
             csv_string,
@@ -395,7 +392,7 @@ def create_folder_and_save_csv(df, folder_name, file_name):
     return "No data to save."
 
 def create_folder():
-    session_id = quotation_project.session_id
+    session_id = state.quotation_project.session_id
     timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
     folder_name = f"quotation_{session_id}_{timestamp}"
     os.makedirs(folder_name, exist_ok=True)

page_prompts_config.py

@@ -16,6 +16,79 @@ class PromptConfig:
     description: str = ""
 
 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=[],
+           editable=True,
+           model="",
+           description="This is the first question that is fixed",
+    ),
+     
+     
+     "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'],
+           editable=True,
+           model=ModelType.O1_MINI,
+           description="Genereate follow-up questions from the provided answers",
+     ),
+     
+     
+    
      "rewrite_qa": PromptConfig(
         prompt="""Rewrite this for clarity while keeping all specific details, metrics, and constraints.
          Do not include context or assumptions beyond the input provided.
@@ -615,7 +688,7 @@ PROMPTS = {
          
          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=['quotation_cost','generated_prd','derived_plan_test_components','derived_dev_components'],
+         inputs=['generated_prd','derived_plan_test_components','derived_dev_components','quotation_cost'],
          outputs=['generated_BD_sow'],
          editable=True,
          model=ModelType.O1_MINI,

state.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+class ProjectType(Enum):
+    Page = "Page"
+    Sage = "Sage"
+    Engage = "Engage"
+
+class GlobalState:
+    def __init__(self):
+        self._quotation_project = None
+
+    @property
+    def quotation_project(self):
+        if self._quotation_project is None:
+            from Project import Project
+            self._quotation_project = Project(ProjectType.Page)
+        return self._quotation_project
+
+    @quotation_project.setter
+    def quotation_project(self, value):
+        self._quotation_project = value
+
+state = GlobalState()