Phase 2 : AI for dynamic render

Project.py

@@ -65,10 +65,9 @@ class Project:
         '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,
+        'generated_plan_test_components': lambda self: self.generated_plan_test_components,
+        'generated_dev_components': lambda self: self.generated_dev_components,
         'quotation_cost': lambda self: self.quotation_cost,
-        'derived_tasks': lambda self: self.derived_tasks,
     }
 
     def execute_prompt(self, prompt_name: str, input_variables: Dict[str, Any] = None) -> str:
@@ -166,12 +165,13 @@ class Project:
             }
         )
 
-#Functions to interact with the frontend#
+## Functions that interact with the steps button handler ##
+# Generate Scope & Components
 def v4_generate_prd_and_components(progress=gr.Progress()):
     """Generate PRD and components from project details"""
     progress(0, desc="Progress 1: Generating PRD from Q&A...")
     generated_prd = state.quotation_project.execute_prompt(
-        "rewrite_qa",
+        "generate_prd",
         {
             "project_detail": state.quotation_project.get_project_detail()
         }
@@ -180,7 +180,7 @@ def v4_generate_prd_and_components(progress=gr.Progress()):
     # 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",
+        "generate_plan_test_components",
         {
             "generated_prd": state.quotation_project.generated_prd
         }
@@ -205,35 +205,40 @@ def v4_generate_prd_and_components(progress=gr.Progress()):
         "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
+# Generate Plan & Test Mandays + Quotation based on components 
+def v4_generate_mandays_and_quotation(plan_test_component, dev_component, progress=gr.Progress()):
+    state.quotation_project.generated_plan_test_components = plan_test_component
+    state.quotation_project.generated_dev_components = dev_component
 
-    # Generate mandays for plan & test components
-    progress(0.5, desc="Progress 1: Deriving Mandays for Plan & Test Components...")
+    # Generate Plan & Test Mandays 
+    progress(0.5, desc="Progress 1: Generating Mandays for Plan & Test Components...")
     plan_test_mandays = state.quotation_project.execute_prompt(
         "generate_plan_test_mandays",
         {
-            "derived_plan_test_components": updated_plan_test_component
+            "generated_plan_test_components": plan_test_component
         }
     )
 
-    # Generate mandays for dev components
-    progress(0.7, desc="Progress 2: Deriving Mandays for Dev Components...")
+    # Generate Dev Mandays 
+    progress(0.7, desc="Progress 2: Generating Mandays for Dev Components...")
     dev_mandays = state.quotation_project.execute_prompt(
         "generate_dev_mandays",
         {
-            "derived_dev_components": updated_dev_component
+            "generated_dev_components": dev_component
         }
     )
     
     print(f"Dev Mandays Result: {dev_mandays}") 
 
-    # Process results - Add error handling and column validation
+    # Convert the results into dataframe
     try:
         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')
 
+        # Standardize column names to lowercase
+        plan_test_df.columns = plan_test_df.columns.str.lower()
+        dev_df.columns = dev_df.columns.str.lower()
+        
         # Validate and standardize column names
         required_plan_test_columns = ['component', 'mandays', 'description']
         required_dev_columns = ['component', 'subcomponent', 'mandays', 'description']
@@ -264,9 +269,10 @@ def v4_generate_quotation(updated_plan_test_component, updated_dev_component, pr
         error_message = f"Error processing CSV data: {str(e)}"
         return [None, None, error_message, "Error calculating costs"]
 
+# Generate BD & Tech SOW
 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.generated_plan_test_components = plan_test_component
+    state.quotation_project.generated_dev_components = dev_component
     state.quotation_project.quotation_cost = cost
 
     # Generate general SOW
@@ -275,19 +281,19 @@ def v4_generate_sow(generated_prd, plan_test_component, dev_component, cost, pro
         "generate_BD_SOW",
         {
             "generated_prd": generated_prd,
-            "derived_plan_test_components": plan_test_component,
-            "derived_dev_components": dev_component,
+            "generated_plan_test_components": plan_test_component,
+            "generated_dev_components": dev_component,
             "quotation_cost": cost
         }
     )
 
-    # Generate detailed SOW
+    # Generate Technical 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
+            "generated_plan_test_components": plan_test_component,
+            "generated_dev_components": dev_component
         }
     )
 
@@ -310,6 +316,7 @@ def v4_generate_sow(generated_prd, plan_test_component, dev_component, cost, pro
     except Exception as e:
         return ["Error generating SOW", "Error: " + str(e), "Failed to generate SOW"]
 
+# Recalculate costs based on modified dataframe values
 def v4_recalculate_cost(plan_test_df, dev_df):
     """Recalculate costs based on modified dataframe values"""
     try:
@@ -336,7 +343,7 @@ def update_display_mode(mode, content):
     else:
         return gr.update(visible=False, value=content), gr.update(visible=True, value=content)
     
-
+# Updates system prompts in both runtime PROMPTS dictionary and config file
 def update_system_prompts(new_prompt: str, prompt_name: str) -> str:
     """Update system prompts in both runtime PROMPTS dictionary and config file
     

app.py

@@ -1,19 +1,18 @@
+from typing import Tuple
 import gradio as gr
 from Project import *
 from common_functions_v4 import *
-from google_drive import * 
+from google_drive import *
 from notion import *
 from state import state
 from page_prompts_config import PROMPTS, ModelType, UIComponentType, UIConfig, PromptConfig
 from typing import Dict, Any, Tuple
 from Project import update_system_prompts
-
-
-with open("page_main.css", "r") as file:
-    custom_css = file.read()
+import pandas as pd
+from io import StringIO
+from step_handlers import setup_all_handlers
 
 def create_ui_component(config: UIConfig, prompt: str = None) -> Any:
-    """Create a single UI component based on configuration"""
     if config.component_type == UIComponentType.TEXTBOX:
         return gr.Textbox(
             label=config.label,
@@ -48,29 +47,22 @@ def create_ui_component(config: UIConfig, prompt: str = None) -> Any:
     return None
 
 def create_section_components(prompt_config: PromptConfig) -> Dict[str, Any]:
-    """Create all UI components for a section based on its prompt configuration"""
     components = {}
     
     with gr.Row():
         with gr.Column(scale=1):
-            # Create editor component if it exists in config
             editor_key = next((k for k in prompt_config.ui.keys() if k.endswith('_prompt_editor')), None)
             if editor_key:
-                # Format the prompt to preserve original structure
-                # Remove any common leading whitespace while preserving relative indentation
                 lines = prompt_config.prompt.split('\n')
                 if lines:
-                    # Find minimum indentation (excluding empty lines)
                     min_indent = min((len(line) - len(line.lstrip()) 
                                    for line in lines if line.strip()), 
                                    default=0)
-                    # Remove common leading whitespace while preserving structure
                     formatted_lines = [
                         line[min_indent:] if line.strip() else ''
                         for line in lines
                     ]
                     formatted_prompt = '\n'.join(formatted_lines)
-                    # Add triple quotes
                     formatted_prompt = f'"""\n{formatted_prompt}\n"""'
                 else:
                     formatted_prompt = '""""""'
@@ -81,12 +73,10 @@ def create_section_components(prompt_config: PromptConfig) -> Dict[str, Any]:
                 )
         
         with gr.Column(scale=1):
-            # Find text and markdown component pairs
             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)
             
             if text_key and markdown_key:
-                # Add radio button for display mode
                 display_mode_key = f"display_mode_{text_key.replace('_text', '')}"
                 components[display_mode_key] = create_ui_component(
                     UIConfig(
@@ -104,7 +94,6 @@ def create_section_components(prompt_config: PromptConfig) -> Dict[str, Any]:
                         prompt_config.ui[markdown_key]
                     )
 
-                # Add event handler for display mode toggle
                 components[display_mode_key].change(
                     fn=update_display_mode,
                     inputs=[
@@ -117,7 +106,6 @@ def create_section_components(prompt_config: PromptConfig) -> Dict[str, Any]:
                     ]
                 )
             else:
-                # Handle other types of components (e.g., dataframe)
                 for key, config in prompt_config.ui.items():
                     if not key.endswith('_prompt_editor'):
                         components[key] = create_ui_component(config)
@@ -125,8 +113,7 @@ def create_section_components(prompt_config: PromptConfig) -> Dict[str, Any]:
     return components
 
 def create_quotation_generator_section():
-    """Creates the quotation generator section with dynamic components based on PROMPTS"""
-    page_units_output = None
+    quotation_cost = None
     page_recalc_btn = None
     page_progress_update = None
     
@@ -140,40 +127,33 @@ def create_quotation_generator_section():
                     "3. **Generate Output**: Proceed to click generate once prompt is edited.",
                     "4. **Upload Quotation**: Upload to Google Drive or Notion"
                 ]:
-                    gr.Markdown(instruction)
+                    gr.Markdown(instruction) 
 
             with gr.Column(scale=1):
                 page_progress_update = gr.Textbox(label="Progress Update", lines=6, interactive=False)
 
         with gr.Row():
             with gr.Column(scale=4):
-                # Step 1: Save System Prompt
                 save_prompts_btn = gr.Button("💾 Save System Prompt")
 
-                # Dynamically group prompts by their step
                 prompt_steps = {}
                 for prompt_key, prompt_config in PROMPTS.items():
                     step = prompt_config.step
-                    # Only group prompts that have a non-empty step value
-                    if step and step.strip():  # Check if step exists and is not just whitespace
+                    if step and step.strip():
                         if step not in prompt_steps:
                             prompt_steps[step] = []
                         prompt_steps[step].append(prompt_key)
 
-                # Create components for each step
                 all_components = {}
                 step_buttons = {}
 
                 for step_name, prompt_keys in prompt_steps.items():
                     with gr.Accordion(step_name, open=False):
-                        # Add generate button for the step
                         button_label = step_name.split(' : ')[1] if ' : ' in step_name else step_name
                         step_buttons[step_name] = gr.Button(f"✅ Generate {button_label}")
                         
-                        # Special layout for Step 2
                         if "Step 2" in step_name:
                             with gr.Row():
-                                # Left column for section components
                                 with gr.Column(scale=4):
                                     for i, prompt_key in enumerate(prompt_keys, 1):
                                         if prompt_key in PROMPTS:
@@ -181,20 +161,16 @@ def create_quotation_generator_section():
                                                 components = create_section_components(PROMPTS[prompt_key])
                                                 all_components[prompt_key] = components
                                 
-                                # Right column for summary and controls
                                 with gr.Column(scale=1):
-                                    page_units_output = gr.Textbox(label="Cost Summary", lines=3, interactive=False)
+                                    quotation_cost = gr.Textbox(label="Cost Summary", lines=3, interactive=False)
                                     page_recalc_btn = gr.Button("Recalculate")
 
-                                    # Add notes section
                                     page_notes_box = gr.Textbox(
                                         label="Notes", 
                                         lines=3, 
                                         placeholder="Add your notes here..."
                                     )
                                     page_save_quotation_btn = gr.Button("Save Quotation with Note")
-                        
-                        # Normal layout for other steps
                         else:
                             for i, prompt_key in enumerate(prompt_keys, 1):
                                 if prompt_key in PROMPTS:
@@ -202,25 +178,22 @@ def create_quotation_generator_section():
                                         components = create_section_components(PROMPTS[prompt_key])
                                         all_components[prompt_key] = components
 
-                # Upload buttons
                 page_upload_btn = gr.Button("📁 Upload to Google Drive")
+                #Still not working :/
                 page_upload_notion_btn = gr.Button(" Upload to Notion")
+                
 
-        # Return the additional components
         return (all_components, step_buttons, save_prompts_btn, 
-                page_progress_update, page_upload_btn, page_upload_notion_btn,
-                page_units_output, page_recalc_btn)  # Add these to the return tuple
+                page_progress_update, page_upload_btn, page_upload_notion_btn, 
+                quotation_cost, page_recalc_btn, page_notes_box, page_save_quotation_btn)
 
 def update_display_mode(mode: str, text_content: str) -> tuple:
-    """Update display mode between text and markdown"""
     return (
         gr.update(visible=(mode == "Textbox"), value=text_content),
         gr.update(visible=(mode == "Markdown"), value=text_content)
-)
+    )
 
 def save_all_prompts(*prompts):
-    """Save all edited prompts that have changed from their original values"""
-    # Get all prompt names from PROMPTS that have a prompt_editor in their UI config
     prompt_names = [
         name for name, config in PROMPTS.items() 
         if config.ui and any(key.endswith('_prompt_editor') for key in config.ui.keys())
@@ -231,14 +204,10 @@ def save_all_prompts(*prompts):
         if not prompt:  
             continue
             
-        # Get original prompt from PROMPTS
         original_prompt = PROMPTS[name].prompt
-        
-        # Clean up both prompts for comparison
         cleaned_prompt = prompt.strip().strip('"""').strip()
         cleaned_original = original_prompt.strip()
         
-        # Only update if the prompt has changed
         if cleaned_prompt != cleaned_original:
             update_system_prompts(prompt, name)
             updated_prompts.append(name)
@@ -247,41 +216,35 @@ def save_all_prompts(*prompts):
         return f"✅ Successfully updated prompt"
     return "No prompts were changed"
 
-################################################################################################
+with open("page_main.css", "r") as file:
+    custom_css = file.read()
 
 with gr.Blocks(title="v3 Page Quotation Chatbot (with SOW)", css=custom_css) as page_interface:
     gr.Markdown("# Page Quotation Chatbot with SOW")
     
-    # Store all components for event handling
     all_components = {}
     
     with gr.Tab(label="Page Main"):
-        # Instructions
         gr.Markdown("## ⚠️ Instructions #1")
         gr.Markdown("### Either select Option 1 or 2 , then scroll down to generate a quotation.")
         gr.Markdown("1. **Start a New Session**: Begin answering questions for a new project.")
         gr.Markdown("2. **Load an Existing Project**: Navigate to the **Load Project** tab.")
 
-        # Session components
         with gr.Row():
             start_btn = gr.Button("Start New Session")
         with gr.Row():
             current_session_display = gr.Markdown(no_active_session)
 
-        # Chat interface
         with gr.Row():
             with gr.Column(scale=1):
-                
                 current_question = gr.Textbox(label="Edit Area", lines=20)
                 submit_btn = gr.Button("Submit")
                 clear_btn = gr.Button("Clear Chat")
             with gr.Column(scale=1):
                 chatbot = gr.Chatbot(height=580)
 
-        # Sample answers
         gr.Markdown("Below are sample answers you can refer to:")
         with gr.Accordion("Sample AR Answers", open=False):
-            # Define labels for each file
             sample_answers = [
                 {'file': 'q1_answer.txt', 'label': 'Company Background & Industry'},
                 {'file': 'q2_answer.txt', 'label': 'Current Challenges & Workflow'},
@@ -296,12 +259,10 @@ with gr.Blocks(title="v3 Page Quotation Chatbot (with SOW)", css=custom_css) as
                         show_copy_button=True
                     )
         
-        # Create quotation generator section with dynamic components
         (all_components, step_buttons, save_prompts_btn, page_progress_update, 
-         page_upload_btn, page_upload_notion_btn,
-         page_units_output, page_recalc_btn) = create_quotation_generator_section()
+         page_upload_btn, page_upload_notion_btn, 
+         quotation_cost, page_recalc_btn, page_notes_box, page_save_quotation_btn) = create_quotation_generator_section()
 
-    # Replace single textbox with separate components
     with gr.Tab(label="Load Project"):
         gr.Markdown("### Past submissions")
         gr.Markdown("Quick hack to load past submissions to regenerate quotations (This page displays Q&A only; previous quotations are not shown yet).")
@@ -319,9 +280,7 @@ with gr.Blocks(title="v3 Page Quotation Chatbot (with SOW)", css=custom_css) as
         
         with gr.Tab(label="Requirement"):
             fetched_requirements_box = gr.Markdown(value="")
-   
-################################################################################################
-    # Event handlers
+
     def setup_event_handlers():
         start_btn.click(
             fn=lambda: (*start_chat(), *get_project_state()),
@@ -338,15 +297,17 @@ with gr.Blocks(title="v3 Page Quotation Chatbot (with SOW)", css=custom_css) as
             fn=lambda: ([], ""),
             outputs=[chatbot, current_question]
         )
-
+        
+        setup_all_handlers(step_buttons, all_components, page_progress_update, quotation_cost)
+        
         page_recalc_btn.click(
             fn=v4_recalculate_cost,
             inputs=[
-                all_components['generate_plan_test_mandays']['page_plan_test_mandays'],
-                all_components['generate_dev_mandays']['page_dev_mandays'],
+                all_components['generate_plan_test_mandays']['generated_plan_test_mandays_dataframe'],
+                all_components['generate_dev_mandays']['generated_dev_mandays_dataframe'],
             ], 
             outputs=[
-                page_units_output,
+                quotation_cost,
                 page_progress_update
             ]
         )
@@ -362,68 +323,19 @@ with gr.Blocks(title="v3 Page Quotation Chatbot (with SOW)", css=custom_css) as
             ]
         )
         
-        prompt_editors = [
-            components[next(k for k in components.keys() if k.endswith('_prompt_editor'))]
-            for components in all_components.values()
-            if any(k.endswith('_prompt_editor') for k in components.keys())
-        ]
-        
         save_prompts_btn.click(
             fn=save_all_prompts,
-            inputs=prompt_editors,
-            outputs=[page_progress_update]
-        ) 
-        
-        # Handlers for step buttons
-        step_buttons["Step 1 : Scope & Components"].click(
-            fn=v4_generate_prd_and_components,
-            inputs=[],  
-            outputs=[
-                all_components['rewrite_qa']['page_prd_box_text'],
-                all_components['rewrite_qa']['page_prd_box_markdown'],
-                all_components['generate_components']['page_plan_test_component_table_text'],
-                all_components['generate_components']['page_plan_test_component_table_markdown'],
-                all_components['generate_dev_components']['page_dev_component_table_text'],
-                all_components['generate_dev_components']['page_dev_component_table_markdown'],
-                page_progress_update
-            ]
-        )
-
-        step_buttons["Step 2 : Planning & Testing Components"].click(
-            fn=v4_generate_quotation,
-            inputs=[
-                all_components['generate_components']['page_plan_test_component_table_text'],
-                all_components['generate_dev_components']['page_dev_component_table_text']
-            ],
-            outputs=[
-                all_components['generate_plan_test_mandays']['page_plan_test_mandays'],
-                all_components['generate_dev_mandays']['page_dev_mandays'],
-                page_progress_update,
-                page_units_output
-            ]
-        )
-
-        step_buttons["Step 3 : SOW Doc"].click(
-            fn=v4_generate_sow,
             inputs=[
-                all_components['rewrite_qa']['page_prd_box_text'],
-                all_components['generate_components']['page_plan_test_component_table_text'],
-                all_components['generate_dev_components']['page_dev_component_table_text'],
-                page_units_output
+                all_components[prompt_key]['prompt_editor']
+                for prompt_key in all_components
+                if 'prompt_editor' in all_components[prompt_key]
             ],
-            outputs=[
-                all_components['generate_BD_SOW']['page_general_sow_text'],
-                all_components['generate_BD_SOW']['page_general_sow_markdown'],
-                all_components['generate_Tech_SOW']['page_detailed_sow_text'],
-                all_components['generate_Tech_SOW']['page_detailed_sow_markdown'],
-                page_progress_update
-            ]
+            outputs=[page_progress_update]
         )
+        
 
-
+    # Call setup_event_handlers after all components are created
     setup_event_handlers()
 
-
 if __name__ == "__main__":
-    page_interface.launch(share=True)
-
+    page_interface.launch(share=True)

code_modifier.py

@@ -1,274 +1,489 @@
-import ast
+from typing import Dict, List, Set, Optional
+from dataclasses import dataclass
+from enum import Enum
+import openai
+from contextlib import contextmanager
+import re
 import json
-from typing import Dict, List
-from Project import call_o1_mini
-from page_prompts_config import PromptConfig, PROMPTS
 
-class PromptConfigAnalyzer:
-    """Analyzes prompt configurations and generates implementation code"""
+@dataclass
+class UIComponent:
+    name: str
+    type: str
+    config: Dict
+
+@dataclass
+class PromptConfig:
+    name: str
+    inputs: List[str]
+    outputs: List[str]
+    ui_components: Dict[str, UIComponent]
+    step: Optional[str] = None
+
+class ChangeType(Enum):
+    ADD_PROMPT = "add_prompt"
+    REMOVE_PROMPT = "remove_prompt"
+    RENAME_PROMPT = "rename_prompt"
+    ADD_INPUT = "add_input"
+    REMOVE_INPUT = "remove_input"
+    RENAME_INPUT = "rename_input"
+    ADD_OUTPUT = "add_output"
+    REMOVE_OUTPUT = "remove_output"
+    RENAME_OUTPUT = "rename_output"
+    ADD_UI = "add_ui"
+    REMOVE_UI = "remove_ui"
+    RENAME_UI = "rename_ui"
+    CHANGE_STEP = "change_step"
+
+@dataclass
+class ConfigChange:
+    type: ChangeType
+    prompt_name: str
+    old_value: Optional[str] = None
+    new_value: Optional[str] = None
+    details: Optional[Dict] = None
+
+@dataclass
+class AnalysisResult:
+    changes: List[ConfigChange]
+    affected_files: Set[str]
+    required_updates: Dict[str, List[Dict]]
     
-    def __init__(self):
-        self.prompt_configs = {}
+@contextmanager
+def openai_session():
+    """Context manager to properly handle OpenAI API sessions"""
+    try:
+        client = openai.OpenAI()
+        yield client
+    finally:
+        if hasattr(client, 'close'):
+            client.close()
+
+def call_o1_mini(prompt: str) -> str:
+    """Call the o1-mini model with the given prompt"""
+    with openai_session() as client:
+        try:
+            response = client.chat.completions.create(
+                model="o1-mini",
+                messages=[{"role": "user", "content": prompt}]
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            return f"Error generating output: {str(e)}"
         
-    def analyze_prompt_config(self, prompt_name: str, config: PromptConfig) -> Dict:
-        """Analyze a single prompt configuration"""
-        analysis = {
-            "name": prompt_name,
-            "method_name": f"execute_{prompt_name}",
-            "inputs": config.inputs,
-            "outputs": config.outputs,
-            "ui_components": [],
-            "state_requirements": []
-        }
-
-        # Analyze UI requirements
-        if config.ui:
-            for component_name, ui_config in config.ui.items():
-                analysis["ui_components"].append({
-                    "name": component_name,
-                    "type": ui_config.component_type,
-                    "config": ui_config
-                })
-
-        # Analyze state requirements
-        for input_var in config.inputs:
-            analysis["state_requirements"].append({
-                "name": input_var,
-                "type": "project_attribute"
-            })
-
-        return analysis
-
-    def generate_method_code(self, analysis: Dict) -> str:
-        """Generate method code for a prompt"""
-        method_name = analysis["method_name"]
-        inputs = analysis["inputs"]
-        outputs = analysis["outputs"]
+def clean_ai_response(response: str) -> str:
+    """Clean the AI response to ensure valid JSON"""
+    try:
+        # Remove any potential markdown code block markers
+        response = re.sub(r'```json\s*', '', response)
+        response = re.sub(r'```\s*$', '', response)
         
-        code = f"""
-    def {method_name}(self, {', '.join(inputs)}) -> Dict[str, Any]:
-        \"\"\"Execute {analysis['name']} prompt
+        # Remove any leading/trailing whitespace
+        response = response.strip()
         
-        Args:
-            {chr(10).join(f'{input_}: str' for input_ in inputs)}
-            
-        Returns:
-            Dict containing: {', '.join(outputs)}
-        \"\"\"
-        try:
-            result = self.execute_prompt(
-                "{analysis['name']}",
+        # Attempt to parse JSON to validate
+        json.loads(response)
+        
+        return response
+    except json.JSONDecodeError as e:
+        print(f"Error cleaning response: {str(e)}")
+        print("Raw response:", response)
+        return "{}"
+
+def analyze_config_structure(config_content: str, project_content: str, current_handlers: str) -> Dict:
+    """First AI: Analyzes the current config structure and determines required changes"""
+    analysis_prompt = f"""
+    You are an expert software analyzer. Your task is to analyze and focus on the configuration structure and validate the relationships between components.
+
+    1. OUTPUT AND INPUT VALIDATION RULES:
+       - Not all outputs/inputs require UI component mappings
+       - Special outputs like 'quotation_cost' can be internal values used as inputs and outputs in other steps
+       - Internal values can be passed between steps without UI components , so just IGNORE them
+       - Examples of internal values:
+         * quotation_cost: Generated as output, used as input in other steps
+         * project_detail: Used as input without UI mapping
+         * gathered_project_input: Internal state passed between steps 
+         * reviewed_project_input: Internal state passed between steps  
+
+    2. OUTPUT TO UI COMPONENT MAPPING RULES:
+       - Most outputs in config map to specific UI components
+       - Standard Output Pattern:
+         * Base output name (e.g., 'generated_prd') MUST map to TWO components:
+           - base_name_text: For textbox display
+           - base_name_markdown: For markdown display
+       - Special Case - Mandays Pattern:
+         * Mandays outputs (e.g., 'generated_plan_test_mandays') MUST map to ONE component:
+           - base_name_dataframe: For dataframe display
+           
+    3. INPUT TO UI COMPONENT MAPPING RULES:
+       - Only UI-interactive inputs need component mappings
+       - When needed, inputs MUST reference either the _text or _markdown variant
+
+    4. NAMING CONVENTION (Source of Truth: Config File)
+       MUST CHECK:
+       - Prompt names (e.g., "generate_dev_components")
+       - Component names (e.g., "generated_Tech_SOW_text")
+       - Input/Output references
+       
+       WHERE TO CHECK:
+       - step_handlers.py: Function names, component references
+       - Project.py: Method names, mappings
+       - all_components dictionary: Component keys
+       
+    5. HANDLER VALIDATION RULES:
+       - Each step handler must correctly map:
+         * Inputs to component _text or _markdown
+         * Outputs to both _text and _markdown (or _dataframe for mandays)
+       - all_components dictionary keys must exactly match config naming
+       - Function parameters should align with Project.py signatures
+
+    Context Files:
+    1. Current Config:
+    {config_content}y
+
+    2. Project.py:
+    {project_content}
+
+    3. step_handlers.py:
+    {current_handlers}
+
+    Return a JSON analysis with this EXACT structure:
+    {{
+        "component_mappings": {{
+            "outputs": [
                 {{
-                    {chr(10).join(f'"{input_}": {input_},' for input_ in inputs)}
+                    "config_name": "base_output_name",
+                    "required_components": ["component1", "component2"],
+                    "current_components": ["existing1", "existing2"],
+                    "is_valid": false,
+                    "issues": ["detailed_issue_description"]
                 }}
-            )
-            
-            return {{
-                {chr(10).join(f'"{output}": result,' for output in outputs)}
-            }}
-            
-        except Exception as e:
-            return {{"error": str(e)}}
-        """
-        return code
-
-    def generate_ui_code(self, analysis: Dict) -> str:
-        """Generate Gradio UI code for a prompt"""
-        components = []
-        for ui_component in analysis["ui_components"]:
-            config = ui_component["config"]
-            component_code = f"""
-            {ui_component['name']} = gr.{config.component_type.value.capitalize()}(
-                label="{config.label}",
-                interactive={config.interactive},
-                visible={config.visible},
-                {'lines=' + str(config.lines) if config.lines else ''}
-                {', show_copy_button=True' if config.show_copy_button else ''}
-            )"""
-            components.append(component_code)
-            
-        return "\n".join(components)
-
-def analyze_and_update_code():
-    """Use AI to analyze configs and generate updated implementations"""
-    
-    # Read configuration and existing files
-    with open("page_prompts_config.py", "r") as f:
-        config_code = f.read()
-    with open("Project.py", "r") as f:
-        project_code = f.read()
-    with open("app.py", "r") as f:
-        app_code = f.read()
-    with open("common_functions_v4.py", "r") as f:
-        common_code = f.read()
-
-    # First, analyze the configuration structure
-    analysis_prompt = f"""Analyze these files and explain how they work together:
-
-Configuration (page_prompts_config.py):
-{config_code}
-
-Current Project Implementation (Project.py):
-{project_code}
-
-Current App Implementation (app.py):
-{app_code}
-
-Current Common Functions (common_functions_v4.py):
-{common_code}
-
-Explain:
-1. How do these components interact?
-2. What is the flow of data between components?
-3. What patterns are used in the implementations?
-4. How should the code be structured to best handle the configurations?
-5. What improvements could be made to the architecture?
-
-Format your response as JSON with these keys: interactions, data_flow, patterns, structure, improvements"""
-
-    print("Analyzing code structure...")
-    analysis = call_o1_mini(analysis_prompt)
-    analysis_json = json.loads(analysis)
-
-    # Generate updated Project.py implementation
-    project_prompt = f"""Based on this analysis, generate an updated Project.py implementation that:
-
-1. Handles all configured prompts from page_prompts_config.py
-2. Maintains existing functionality while improving code structure
-3. Implements proper error handling and logging
-4. Uses type hints and documentation
-5. Follows Python best practices
-
-Analysis:
-{json.dumps(analysis_json, indent=2)}
-
-Current Implementation:
-{project_code}
-
-Configuration:
-{config_code}
-
-Rules:
-- Keep existing functionality intact
-- Improve code organization
-- Add better error handling
-- Maintain compatibility with app.py
-- Add comprehensive documentation
-
-Format the response as a complete Python file."""
-
-    print("Generating Project.py implementation...")
-    project_implementation = call_o1_mini(project_prompt)
-
-    # Generate updated app.py implementation
-    app_prompt = f"""Based on this analysis, generate an updated app.py implementation that:
-
-1. Creates a Gradio interface matching the configuration
-2. Maintains existing functionality while improving structure
-3. Handles all events and user interactions
-4. Provides better error handling and feedback
-5. Follows the specified layout structure
-
-Analysis:
-{json.dumps(analysis_json, indent=2)}
-
-Current Implementation:
-{app_code}
-
-Configuration:
-{config_code}
-
-Rules:
-- Keep existing functionality intact
-- Improve UI component generation
-- Better state management
-- Maintain all current features
-- Add better error handling
-
-Format the response as a complete Python file."""
-
-    print("Generating app.py implementation...")
-    app_implementation = call_o1_mini(app_prompt)
-
-    # Generate updated common_functions_v4.py implementation
-    common_prompt = f"""Based on this analysis, generate an updated common_functions_v4.py implementation that:
-
-1. Maintains all existing utility functions
-2. Improves code organization and structure
-3. Adds better error handling
-4. Updates function signatures as needed
-5. Improves documentation
-
-Analysis:
-{json.dumps(analysis_json, indent=2)}
-
-Current Implementation:
-{common_code}
-
-Configuration:
-{config_code}
-
-Rules:
-- Keep existing functionality intact
-- Improve code organization
-- Add better error handling
-- Update type hints
-- Add comprehensive documentation
-
-Format the response as a complete Python file."""
-
-    print("Generating common_functions_v4.py implementation...")
-    common_implementation = call_o1_mini(common_prompt)
-
-    # Validate all implementations
-    validation_prompt = f"""Validate these implementations for:
-1. Completeness - all current functionality is maintained
-2. Correctness - code will work as intended
-3. Best practices - code follows Python conventions
-4. Error handling - all edge cases are covered
-5. Integration - components work together properly
-
-Project Implementation:
-{project_implementation}
-
-App Implementation:
-{app_implementation}
-
-Common Functions Implementation:
-{common_implementation}
-
-Provide any necessary corrections in JSON format with these keys: project_fixes, app_fixes, common_fixes"""
-
-    print("Validating implementations...")
-    validation = call_o1_mini(validation_prompt)
-    validation_json = json.loads(validation)
+            ],
+            "inputs": [
+                {{
+                    "config_name": "input_name",
+                    "required_component": "required_component_name",
+                    "current_component": "current_component_name",
+                    "is_valid": false,
+                    "issues": ["detailed_issue_description"]
+                }}
+            ]
+        }},
+        "step_handlers": {{
+            "steps": [
+                {{
+                    "step": "step_number",
+                    "input_mappings": {{
+                        "is_valid": false,
+                        "issues": ["detailed_issue_description"]
+                    }},
+                    "output_mappings": {{
+                        "is_valid": false,
+                        "issues": ["detailed_issue_description"]
+                    }}
+                }}
+            ]
+        }},
+        "required_updates": {{
+            "Project.py": [
+                {{
+                    "type": "method|mapping",
+                    "location": "exact_location",
+                    "reason": "detailed_explanation"
+                }}
+            ],
+            "step_handlers.py": [
+                {{
+                    "step": "step_number",
+                    "type": "component|input|output",
+                    "current": "current_code",
+                    "required": "required_code",
+                    "reason": "detailed_explanation"
+                }}
+            ]
+        }}
+    }}
+
+    IMPORTANT:
+    1. Validate EVERY output has correct component mappings
+    2. Check EVERY input references correct component variant
+    3. Verify ALL component names match exactly
+    4. Flag ANY case mismatches or naming inconsistencies
+    5. Return ONLY the JSON object, no additional text
+    """
+
+    try:
+        result = call_o1_mini(analysis_prompt)
+        cleaned_result = clean_ai_response(result)
+        return json.loads(cleaned_result)
+    except Exception as e:
+        print(f"Error in analysis: {str(e)}")
+        print("Raw response:", result)
+        return {
+            "component_mappings": {"outputs": [], "inputs": []},
+            "step_handlers": {"steps": []},
+            "required_updates": {}
+        }
 
-    # Apply any fixes
-    if validation_json.get('project_fixes'):
-        project_implementation = apply_fixes(project_implementation, validation_json['project_fixes'])
-    if validation_json.get('app_fixes'):
-        app_implementation = apply_fixes(app_implementation, validation_json['app_fixes'])
-    if validation_json.get('common_fixes'):
-        common_implementation = apply_fixes(common_implementation, validation_json['common_fixes'])
 
-    # Save implementations
-    print("Saving updated implementations...")
-    with open("Project.py", "w") as f:
-        f.write(project_implementation)
-    with open("app.py", "w") as f:
-        f.write(app_implementation)
-    with open("common_functions_v4.py", "w") as f:
-        f.write(common_implementation)
+def generate_code_updates(analysis_result: Dict) -> Dict:
+    """Second AI: Generates specific code updates based on the analysis"""
+    code_generation_prompt = f"""
+    You are an expert code generator. Based on this analysis, generate EXACT code updates.
+    
+    Analysis Result:
+    {json.dumps(analysis_result, indent=2)}
 
-    return "Successfully updated all implementation files based on configuration analysis"
+    Generate a JSON response with this EXACT structure:
+    {{
+        "Project.py": {{
+            "updates": [
+                {{
+                    "location": "exact_location",
+                    "explanation": "detailed_explanation",
+                    "old_code": "existing_code",
+                    "new_code": "updated_code"
+                }}
+            ]
+        }},
+        "step_handlers.py": {{
+            "updates": [
+                {{
+                    "location": "exact_location",
+                    "explanation": "detailed_explanation",
+                    "old_code": "existing_code",
+                    "new_code": "updated_code"
+                }}
+            ]
+        }}
+    }}
+
+    Requirements:
+    1. Maintain exact function signatures
+    2. Preserve existing code structure
+    3. Only generate the specific changes needed
+    4. Include clear comments explaining changes
+    5. Each file must have an 'updates' array, even if empty
+
+    IMPORTANT: Return ONLY the JSON object, without any markdown formatting or explanation.
+    Do not include ```json or ``` markers.
+    """
+    
+    try:
+        result = call_o1_mini(code_generation_prompt)
+        cleaned_result = clean_ai_response(result)
+        parsed_result = json.loads(cleaned_result)
+        
+        # Ensure correct structure
+        if "Project.py" not in parsed_result:
+            parsed_result["Project.py"] = {"updates": []}
+        if "step_handlers.py" not in parsed_result:
+            parsed_result["step_handlers.py"] = {"updates": []}
+            
+        # Ensure updates array exists
+        if "updates" not in parsed_result["Project.py"]:
+            parsed_result["Project.py"]["updates"] = []
+        if "updates" not in parsed_result["step_handlers.py"]:
+            parsed_result["step_handlers.py"]["updates"] = []
+            
+        return parsed_result
+        
+    except Exception as e:
+        print(f"Error generating code updates: {str(e)}")
+        print("Raw response:", result)
+        return {
+            "Project.py": {"updates": []},
+            "step_handlers.py": {"updates": []}
+        }
 
-def apply_fixes(code: str, fixes: dict) -> str:
-    """Apply fixes to generated code"""
-    # Implementation of fix application logic
-    # This would parse the code and apply the specified fixes
-    return code
+def apply_project_updates(updates: List[Dict]) -> bool:
+    """Apply updates to Project.py"""
+    try:
+        with open('Project.py', 'r') as f:
+            content = f.read()
+            
+        for update in updates:
+            if update['type'] == 'method':
+                # Add new methods before the last class method
+                class_end = content.rfind('\n\n')
+                if class_end == -1:
+                    return False
+                content = content[:class_end] + '\n' + update['new_code'] + content[class_end:]
+                
+            elif update['type'] == 'mapping':
+                # Update INPUT_MAPPINGS
+                input_mappings_start = content.find('INPUT_MAPPINGS = {')
+                if input_mappings_start != -1:
+                    input_mappings_end = content.find('}', input_mappings_start)
+                    if input_mappings_end != -1:
+                        # Replace old mapping with new one
+                        content = content[:input_mappings_start] + update['new_code'] + content[input_mappings_end + 1:]
+        
+        with open('Project.py', 'w') as f:
+            f.write(content)
+            
+        return True
+        
+    except Exception as e:
+        print(f"Error applying Project.py updates: {str(e)}")
+        return False
+
+def apply_handler_updates(updates: List[Dict]) -> bool:
+    """Apply updates to step_handlers.py"""
+    try:
+        with open('step_handlers.py', 'r') as f:
+            content = f.read()
+            
+        for update in updates:
+            if update['type'] == 'component':
+                # Update component references
+                content = content.replace(update['old_code'], update['new_code'])
+            elif update['type'] == 'input':
+                # Update input parameters
+                pattern = rf"inputs=\[([^\]]*)\]"
+                replacement = f"inputs=[{update['new_code']}]"
+                content = re.sub(pattern, replacement, content)
+            elif update['type'] == 'output':
+                # Update output parameters
+                pattern = rf"outputs=\[([^\]]*)\]"
+                replacement = f"outputs=[{update['new_code']}]"
+                content = re.sub(pattern, replacement, content)
+                    
+        with open('step_handlers.py', 'w') as f:
+            f.write(content)
+            
+        return True
+        
+    except Exception as e:
+        print(f"Error applying handler updates: {str(e)}")
+        return False
+
+def extract_config_without_prompts() -> str:
+    """Extract config file content without prompts"""
+    try:
+        with open('page_prompts_config.py', 'r') as f:
+            config_lines = []
+            in_prompt_block = False
+            in_multiline_string = False
+            prompt_indent = 0
+            
+            for line in f:
+                stripped_line = line.strip()
+                
+                # Skip empty lines
+                if not stripped_line:
+                    continue
+                
+                # Detect start of multi-line string
+                if '"""' in line:
+                    if not in_multiline_string:
+                        in_multiline_string = True
+                        in_prompt_block = True
+                        continue
+                    else:
+                        in_multiline_string = False
+                        in_prompt_block = False
+                        continue
+                
+                # Skip lines while in a prompt block
+                if in_prompt_block or in_multiline_string:
+                    continue
+                
+                # Detect single-line prompt assignments
+                if 'prompt=' in line and not in_multiline_string:
+                    continue
+                
+                # Keep all other lines
+                config_lines.append(line)
+            
+            return ''.join(config_lines)
+    except Exception as e:
+        return f"Error reading config file: {str(e)}"
+
+def main():
+    """Main function to handle config changes"""
+    try:
+        # Read current files
+        config_content = extract_config_without_prompts()
+        if config_content.startswith("Error"):
+            print(config_content)
+            return
+            
+        with open('Project.py', 'r') as f:
+            project_content = f.read()
+        with open('step_handlers.py', 'r') as f:
+            current_handlers = f.read()
+
+        # First AI: Analyze current structure
+        print("\nAnalyzing configuration structure...")
+        analysis_result = analyze_config_structure(config_content, project_content, current_handlers)
+
+        if not analysis_result.get('component_mappings'):
+            print("Error: Invalid analysis result format")
+            return
+
+        # Display analysis results
+        print("\nConfiguration Analysis:")
+        print("1. Output Mappings:", len(analysis_result['component_mappings']['outputs']))
+        print("2. Input Mappings:", len(analysis_result['component_mappings']['inputs']))
+        print("3. Step Handlers:", len(analysis_result['step_handlers']['steps']))
+
+        if analysis_result.get('required_updates'):
+            print("\nRequired Updates:")
+            for file, updates in analysis_result['required_updates'].items():
+                print(f"\n{file}:")
+                for update in updates:
+                    print(f"- {update['type']}: {update['reason']}")
+
+        if analysis_result.get('validation_issues'):
+            print("\nValidation Issues:")
+            for issue in analysis_result['validation_issues']:
+                print(f"- {issue['type']} ({issue['severity']}): {issue['description']}")
+
+        # Get user confirmation
+        confirm = input("\nProceed with generating code updates? (y/n): ")
+        if confirm.lower() != 'y':
+            print("Analysis complete. Update cancelled.")
+            return
+
+        # Second AI: Generate code updates
+        print("\nGenerating code updates...")
+        code_updates = generate_code_updates(analysis_result)
+
+        # Display proposed changes
+        print("\nProposed Code Updates:")
+        for file, updates in code_updates.items():
+            print(f"\n{file}:")
+            for update in updates['updates']:
+                print(f"- Location: {update['location']}")
+                print(f"  Explanation: {update['explanation']}")
+                print("  Old code:")
+                print(f"```\n{update['old_code']}\n```")
+                print("  New code:")
+                print(f"```\n{update['new_code']}\n```")
+
+        # Final confirmation
+        confirm = input("\nApply these code updates? (y/n): ")
+        if confirm.lower() != 'y':
+            print("Updates cancelled.")
+            return
+
+        # Apply updates
+        success = True
+        if 'Project.py' in code_updates:
+            success &= apply_project_updates(code_updates['Project.py']['updates'])
+        if 'step_handlers.py' in code_updates:
+            success &= apply_handler_updates(code_updates['step_handlers.py']['updates'])
+
+        if success:
+            print("Successfully updated all files")
+        else:
+            print("Some updates failed - please check the files manually")
+
+    except Exception as e:
+        print(f"Error in update process: {str(e)}")
+        import traceback
+        print("Traceback:", traceback.format_exc())
 
 if __name__ == "__main__":
-    print("Starting AI-based code analysis and generation...")
-    result = analyze_and_update_code()
-    print(result)
+    main()

code_updater.py

@@ -0,0 +1,345 @@
+from typing import Dict
+import openai
+from contextlib import contextmanager
+import re
+import json
+
+@contextmanager
+def openai_session():
+    """Context manager to properly handle OpenAI API sessions"""
+    try:
+        client = openai.OpenAI()
+        yield client
+    finally:
+        if hasattr(client, 'close'):
+            client.close()
+
+def call_o1_mini(prompt: str) -> str:
+    """Call the o1-mini model with the given prompt"""
+    with openai_session() as client:
+        try:
+            response = client.chat.completions.create(
+                model="o1-mini",
+                messages=[{"role": "user", "content": prompt}]
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            return f"Error generating output: {str(e)}"
+
+def extract_config_without_prompts() -> str:
+    """Extract config file content without prompts"""
+    try:
+        with open('page_prompts_config.py', 'r') as f:
+            config_lines = []
+            in_prompt_block = False
+            in_multiline_string = False
+            prompt_indent = 0
+            
+            for line in f:
+                stripped_line = line.strip()
+                
+                # Skip empty lines
+                if not stripped_line:
+                    continue
+                
+                # Detect start of multi-line string
+                if '"""' in line:
+                    if not in_multiline_string:
+                        in_multiline_string = True
+                        in_prompt_block = True
+                        continue
+                    else:
+                        in_multiline_string = False
+                        in_prompt_block = False
+                        continue
+                
+                # Skip lines while in a prompt block
+                if in_prompt_block or in_multiline_string:
+                    continue
+                
+                # Detect single-line prompt assignments
+                if 'prompt=' in line and not in_multiline_string:
+                    continue
+                
+                # Keep all other lines
+                config_lines.append(line)
+            
+            return ''.join(config_lines)
+    except Exception as e:
+        return f"Error reading config file: {str(e)}"
+
+def analyze_files(config_content: str, project_content: str, current_handlers: str) -> dict:
+    """First analyze all files and extract relevant information"""
+    analysis_prompt = f"""   
+You are an expert software engineer performing a comprehensive analysis. You must understand these key relationships:
+
+1. Config Output to UI Components Mapping:
+   - A single output in config (e.g., 'generated_bd_SOW') can map to multiple UI components
+   - UI components typically come in pairs:
+     * _text: For textbox display
+     * _markdown: For markdown display
+   - As for mandays , it only maps to one UI components which is in *_dataframe
+   Example:
+   Config output 'generated_bd_SOW' maps to:
+   - generated_bd_SOW_text
+   - generated_bd_SOW_markdown
+   
+2. Config Input to UI Component Mapping : 
+   - The inputs should take the _text or _markdown of the component
+
+3. Component Name and Config Key Validation:
+   - Names in handlers must exactly match config
+   - Both section names and component names must match 
+   - Pay special attention to component name changes
+   - Pay attention to case sensitivity
+
+4. Prompt Name Validation : 
+   - Prompt names in config are the source of truth 
+   - Any references to these names in Project.py and step_handlers.py must match EXACTLY
+   - Check for:
+         * Function names in step_handlers.py
+         * Component references in all_components dictionary
+         * Input/output mappings in step handlers
+         * Method names in Project.py
+   
+4. Input/Output Name Validation:
+   - Config keys must match exactly in handlers
+   - Check all_components dictionary keys in handlers against config
+   - Example: if config uses 'generate_development_mandays', handlers must use the same key
+   - Flag any mismatches between config keys and handler references
+
+4. Function Parameter Mapping:
+   - Function parameters in Project.py define the actual data flow
+   - UI components must map to these parameters correctly
+
+Context Files:
+
+1. page_prompts_config.py (SOURCE OF TRUTH FOR NAMES & UI):
+{config_content}
+
+2. Project.py (SOURCE OF TRUTH FOR FUNCTION PARAMETERS):
+{project_content}
+
+3. step_handlers.py (NEEDS VALIDATION):
+{current_handlers}
+
+Analysis Requirements:
+
+1. UI Component Validation:
+   - Check each config output's UI components
+   - Verify both _text and _markdown variants exist where specified
+   - Ensure case matches exactly
+
+2. Component Name Validation:
+   - Compare against config definitions
+   - Check both section names and component names
+   - Flag any case mismatches
+
+3. Function Parameter Validation:
+   - Verify against Project.py signatures
+   - Check parameter order and types
+   - Ensure all required parameters are included
+
+   
+Return your analysis in this EXACT JSON format:
+{{
+    "step_1": {{
+        "current_code": "exact current handler code",
+        "needs_update": false,
+        "updates": []
+    }},
+    "step_2": {{
+        "current_code": "exact current handler code",
+        "needs_update": true,
+        "updates": [
+            {{
+                "type": "component_name",
+                "line": "all_components['generate_BD_SOW']['generated_BD_SOW_text']",
+                "replacement": "all_components['generate_bd_SOW']['generated_bd_SOW_text']",
+                "reason": "Case mismatch with config definition"
+            }}
+        ]
+    }},
+    "step_3": {{
+        "current_code": "exact current handler code",
+        "needs_update": true,
+        "updates": [
+            {{
+                "type": "component_name",
+                "line": "all_components['generate_BD_SOW']['generated_BD_SOW_text']",
+                "replacement": "all_components['generate_bd_SOW']['generated_bd_SOW_text']",
+                "reason": "Case mismatch with config definition"
+            }}
+        ]
+    }}
+}}
+
+Requirements:
+1. Include ALL steps (1-3)
+2. For each step:
+   - Include exact current code
+   - Set needs_update to true if changes needed
+   - List ALL required updates
+3. For each update:
+   - Provide exact current line
+   - Provide exact replacement
+   - Include clear reason
+4. Check:
+   - Case sensitivity
+   - Component names
+   - Function parameters
+   - UI component mappings
+   
+Every discrepancy must be reported as an issue with:
+- Clear description of the problem
+- Exact current implementation
+- Exact expected implementation from config
+- Specific location in the code
+
+If no issues are found for a step, include an empty issues array.
+
+Remember: 
+- Component names must match config
+- Function parameters must match Project.py signatures
+- Some components may be correct in function but need case fixes from config
+- DO NOT suggest changes unless there is a 100% exact mismatch
+- If a component or parameter does not have any changes and it does exist and works, DO NOT suggest changes
+"""
+    
+    analysis = call_o1_mini(analysis_prompt)
+    return analysis
+
+def generate_handler_code(step_number: int, analysis_result: dict) -> str:
+    """Generate the handler code based on the analysis"""
+    step_key = f"step_{step_number}"
+    step_data = analysis_result.get(step_key, {})
+    
+    if not step_data.get("needs_update", False):
+        return ""
+        
+    current_code = step_data["current_code"]
+    updates = step_data.get("updates", [])
+    
+    # Apply all updates
+    updated_code = current_code
+    for update in updates:
+        updated_code = updated_code.replace(update["line"], update["replacement"])
+    
+    return updated_code
+
+def analyze_prompts_and_generate_handlers() -> Dict[int, str]:
+    """Generate step handlers separately"""
+    try:
+        # Read all files once
+        config_content = extract_config_without_prompts()
+        print("\nConfig content loaded")
+        
+        with open('Project.py', 'r') as f:
+            project_content = f.read()
+        print("Project.py content loaded")
+            
+        with open('step_handlers.py', 'r') as f:
+            current_handlers = f.read()
+        print("step_handlers.py content loaded")
+        
+        # Do one analysis for all files
+        print("\nAnalyzing all files...")
+        analysis_result = analyze_files(config_content, project_content, current_handlers)
+        
+        # Parse the analysis result from string to JSON
+        try:
+            if isinstance(analysis_result, str):
+                # Remove ```json and ``` markers if present
+                analysis_result = analysis_result.replace('```json\n', '').replace('\n```', '').strip()
+                analysis_result = json.loads(analysis_result)
+            
+            print("\nRaw analysis result:")
+            print(json.dumps(analysis_result, indent=2))
+
+            handlers = {}
+            for step in range(1, 4):
+                step_key = f"step_{step}"
+                if step_key not in analysis_result:
+                    print(f"\nNo analysis results found for {step_key}")
+                    continue
+                    
+                step_code = generate_handler_code(step, analysis_result)
+                
+                # Clean up and validate the response
+                if step_code:
+                    step_code = step_code.strip()
+                    
+                    if not step_code.startswith(f"step_buttons['Step {step}"):
+                        print(f"\nInvalid handler code format for Step {step}")
+                        # Extract current handler as fallback
+                        pattern = rf"step_buttons\['Step {step} : [^']*'\]\.click\([^)]+\)"
+                        current_handler = re.search(pattern, current_handlers, re.DOTALL)
+                        handlers[step] = current_handler.group(0) if current_handler else None
+                    else:
+                        handlers[step] = step_code
+                        print(f"Generated handler for Step {step}")
+            
+            return handlers
+
+        except json.JSONDecodeError as e:
+            print(f"Error parsing analysis result: {str(e)}")
+            print("Raw analysis result:", analysis_result)
+            return {}
+
+    except Exception as e:
+        print(f"Error generating handlers: {str(e)}")
+        import traceback
+        print("Traceback:", traceback.format_exc())
+        return {}
+
+def main():
+    """Generate and save the step handlers"""
+    handlers = analyze_prompts_and_generate_handlers()
+    print("Generated handlers for steps:", list(handlers.keys()))
+    
+    # Let the user review the changes
+    for step, code in handlers.items():
+        if not code:  
+            continue
+            
+        print(f"\nStep {step} Handler:")
+        print(code)
+        update = input(f"Do you want to update Step {step} handler? (y/n): ")
+        
+        if update.lower() == 'y':
+            try:
+                # Read current content
+                with open('step_handlers.py', 'r') as f:
+                    content = f.read()
+                
+                # Find and replace the specific step handler
+                pattern = rf"step_buttons\['Step {step} : [^']*'\]\.click\([^)]+\)"
+                match = re.search(pattern, content, re.DOTALL)
+                
+                if not match:
+                    print(f"Warning: Couldn't find Step {step} handler in file")
+                    continue
+                
+                # Replace the matched content with the new code
+                updated_content = content[:match.start()] + code.strip() + content[match.end():]
+                
+                # Write back to file
+                with open('step_handlers.py', 'w') as f:
+                    f.write(updated_content)
+                    
+                print(f"Successfully updated Step {step} handler in step_handlers.py")
+                
+                # Verify the write
+                with open('step_handlers.py', 'r') as f:
+                    new_content = f.read()
+                if code.strip() in new_content:
+                    print("Verified: Update successful")
+                else:
+                    print("Warning: Update may not have been successful")
+                    
+            except Exception as e:
+                print(f"Error updating file: {str(e)}")
+                print(f"Error details: {type(e).__name__}")
+
+if __name__ == "__main__":
+    main()

page_prompts_config.py

@@ -128,7 +128,7 @@ PROMPTS = {
         }
     ),
 
-    "rewrite_qa": PromptConfig(
+    "generate_prd": PromptConfig(
         prompt=
         """
         Rewrite this for clarity while keeping all specific details, metrics, and constraints.
@@ -144,19 +144,19 @@ PROMPTS = {
         ui={
             "requirement_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="Requirements System Prompt",
+                label="Requirements(PRD) System Prompt",
                 lines=20,
                 interactive=True
             ),
-            "page_prd_box_text": UIConfig(
+            "generated_prd_text": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="Requirements Output",
+                label="Requirements(PRD) Output",
                 lines=20,
                 visible=True
             ),
-            "page_prd_box_markdown": UIConfig(
+            "generated_prd_markdown": UIConfig(
                 component_type=UIComponentType.MARKDOWN,
-                label="Requirements Output",
+                label="Requirements(PRD) Output",
                 visible=False,
                 show_copy_button=True
             )
@@ -248,7 +248,7 @@ PROMPTS = {
         }
     ),
 
-    "generate_components": PromptConfig(
+    "generate_plan_test_components": PromptConfig(
         prompt=
         """
         Context:
@@ -268,24 +268,24 @@ PROMPTS = {
         Include sub-bullets for tasks or subcomponents where necessary to provide additional detail.
         """,
         inputs=["generated_prd"],
-        outputs=["derived_plan_test_components"],
+        outputs=["generated_plan_test_components"],
         model=ModelType.O1_MINI,
         description="Generate planning and testing components",
         step="Step 1 : Scope & Components",
         ui={
-            "plan_text_prompt_editor": UIConfig(
+            "plan_test_component_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
                 label="Plan Test System Prompt",
                 lines=20,
                 interactive=True
             ),
-            "page_plan_test_component_table_text": UIConfig(
+            "generated_plan_test_components_text": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
                 label="Plan & Test Components Output",
                 lines=20,
                 visible=True
             ),
-            "page_plan_test_component_table_markdown": UIConfig(
+            "generated_plan_test_components_markdown": UIConfig(
                 component_type=UIComponentType.MARKDOWN,
                 label="Plan & Test Components Output",
                 visible=False,
@@ -334,24 +334,24 @@ PROMPTS = {
         Please respond in English only.
         """,
         inputs=["generated_prd"],
-        outputs=["derived_dev_components"],
+        outputs=["generated_dev_components"],
         model=ModelType.O1_MINI,
         description="Generate development components",
         step="Step 1 : Scope & Components",
         ui={
-            "dev_prompt_editor": UIConfig(
+            "dev_component_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
                 label="Development System Prompt",
                 lines=20,
                 interactive=True
             ),
-            "page_dev_component_table_text": UIConfig(
+            "generated_dev_components_text": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
                 label="Development Components Output",
                 lines=20,
                 visible=True
             ),
-            "page_dev_component_table_markdown": UIConfig(
+            "generated_dev_components_markdown": UIConfig(
                 component_type=UIComponentType.MARKDOWN,
                 label="Developemnt Components Output",
                 visible=False,
@@ -360,15 +360,11 @@ PROMPTS = {
         }
     ),
 
-
     "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.
 
-        Input Components:
-        {derived_plan_test_components}
-        
         Objective:
         Generate a structured CSV output with manday estimates for each planning and testing component.
 
@@ -393,19 +389,19 @@ PROMPTS = {
 
         Return only the CSV content, no code blocks or additional text.
         """,
-        inputs=["derived_plan_test_components"],
-        outputs=["plan_test_mandays"],
+        inputs=["generated_plan_test_components"],
+        outputs=["generated_plan_test_mandays"],
         model=ModelType.O1_MINI,
-        description="Generate planning and testing mandays",
-        step="Step 2 : Planning & Testing Components",
+        description="Generate planning and testing mandays from plan_test components table",
+        step="Step 2 : Planning & Testing Mandays",
         ui={
-            "plantest_mandays_prompt_editor": UIConfig(
+            "plan_test_mandays_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
                 label="Planning & Testing Mandays System Prompt",
                 lines=20,
                 interactive=True
             ),
-            "page_plan_test_mandays": UIConfig(
+            "generated_plan_test_mandays_dataframe": UIConfig(
                 component_type=UIComponentType.DATAFRAME,
                 label="Plan & Test Mandays",
                 interactive=True
@@ -418,8 +414,6 @@ PROMPTS = {
         """
         You are an experienced project manager tasked to create a detailed task breakdown for development components.
         
-        Input Components:
-        {derived_dev_components}
 
         Objective:
         Generate a structured CSV output with manday estimates for each development component and subcomponent from the provided development component list.
@@ -454,11 +448,11 @@ PROMPTS = {
 
         YOU MUST GENERATE ACTUAL DATA ROWS based on the development component list provided.
         """,
-        inputs=["derived_dev_components"],
-        outputs=["dev_mandays"],
+        inputs=["generated_dev_components"],
+        outputs=["generated_dev_mandays"],
         model=ModelType.O1_MINI,
-        description="Generate development mandays",
-        step="Step 2 : Planning & Testing Components",
+        description="Generate development mandays from dev components table",
+        step="Step 2 : Planning & Testing Mandays",
         ui={
             "dev_mandays_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
@@ -466,7 +460,7 @@ PROMPTS = {
                 lines=20,
                 interactive=True
             ),
-            "page_dev_mandays": UIConfig(
+            "generated_dev_mandays_dataframe": UIConfig(
                 component_type=UIComponentType.DATAFRAME,
                 label="Dev Mandays",
                 interactive=True
@@ -521,7 +515,7 @@ PROMPTS = {
           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,
@@ -584,7 +578,7 @@ PROMPTS = {
         """
         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
+        ### **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).
@@ -603,7 +597,7 @@ PROMPTS = {
           - Textual Description: Detailed explanation of the processes and transitions 
         - Use bullet point, ensure simplicity and avoid overly technical langua
         #### **5. Modules and Functional Requirements Breakdown**
-        - LEAVE THIS BL
+        - 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).
@@ -625,7 +619,7 @@ PROMPTS = {
             - Expected Date/Duration
             - Outcome/Deliverable
         - Use a Gantt chart or table to visualize the timeline.
-        - Ensure the output are clean, organized, and easy to re
+        - 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
@@ -634,7 +628,7 @@ PROMPTS = {
           - 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 bla
+        - 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. 
@@ -642,15 +636,15 @@ PROMPTS = {
              - Signature
              - Name
              - Position
-             - D
+             - Date
         #### **Guidelines**
         - Use bullet points for clarity.
         - Keep descriptions concise and client-friendly; avoid technical jargon unless necessary.
-        - Maintain structured sections and tables for readabili
+        - 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", "derived_plan_test_components", "derived_dev_components", "quotation_cost"],
-        outputs=["general_sow"],
+        inputs=["generated_prd", "generated_plan_test_components", "generated_dev_components", "quotation_cost"],
+        outputs=["generated_BD_SOW"],
         model=ModelType.O1_MINI,
         description="Generate BD SOW",
         step="Step 3 : SOW Doc",
@@ -661,13 +655,13 @@ PROMPTS = {
                 lines=20,
                 interactive=True
             ),
-            "page_general_sow_text": UIConfig(
+            "generated_BD_SOW_text": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
                 label="BD SOW Doc",
                 lines=20,
                 visible=True
             ),
-            "page_general_sow_markdown": UIConfig(
+            "generated_BD_SOW_markdown": UIConfig(
                 component_type=UIComponentType.MARKDOWN,
                 label="BD SOW Doc",
                 visible=False,
@@ -675,7 +669,7 @@ PROMPTS = {
             )
         }
     ),
-
+    
     "generate_Tech_SOW": PromptConfig(
         prompt=
         """
@@ -724,8 +718,8 @@ PROMPTS = {
           "system_flow": <markdown content>
         }
         """,
-        inputs=["derived_plan_test_components", "derived_dev_components"],
-        outputs=["detailed_sow"],
+        inputs=["generated_plan_test_components", "generated_dev_components"],
+        outputs=["generated_Tech_SOW"],
         model=ModelType.O1_MINI,
         description="Generate Test SOW",
         step="Step 3 : SOW Doc",
@@ -736,13 +730,13 @@ PROMPTS = {
                 lines=20,
                 interactive=True
             ),
-            "page_detailed_sow_text": UIConfig(
+            "generated_Tech_SOW_text": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
                 label="Technical SOW Doc",
                 lines=20,
                 visible=True
             ),
-            "page_detailed_sow_markdown": UIConfig(
+            "generated_Tech_SOW_markdown": UIConfig(
                 component_type=UIComponentType.MARKDOWN,
                 label="Technical SOW Doc",
                 visible=False,
@@ -750,5 +744,6 @@ PROMPTS = {
             )
         }
     ),    
+
 }
   

step_handlers.py

@@ -0,0 +1,48 @@
+from Project import *
+
+def setup_all_handlers(step_buttons, all_components, page_progress_update, quotation_cost):
+    """Set up all step handlers with the provided UI components"""
+    step_buttons['Step 1 : Scope & Components'].click(
+        fn=v4_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'],
+            page_progress_update
+        ],
+    )
+
+    step_buttons['Step 2 : Planning & Testing Mandays'].click(
+        fn=v4_generate_mandays_and_quotation,
+        inputs=[
+            all_components['generate_plan_test_components']['generated_plan_test_components_text'],
+            all_components['generate_dev_components']['generated_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,
+            quotation_cost
+        ],
+    )
+
+    step_buttons['Step 3 : SOW Doc'].click(
+    fn=v4_generate_sow,
+    inputs=[
+        all_components['generate_prd']['generated_prd_text'],
+        all_components['generate_plan_test_components']['generated_plan_test_components_text'],
+        all_components['generate_dev_components']['generated_dev_components_text'],
+        quotation_cost
+    ],
+    outputs=[
+        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
+    ],
+)