- fixed gdrive

- modified prompt

Project.py

@@ -46,6 +46,7 @@ def call_4o_mini(prompt):
             return response.choices[0].message.content
         except Exception as e:
             return f"Error generating output: {str(e)}"
+        
 
 class Project: 
     def __init__(self, project_type, session_id=None):
@@ -416,10 +417,18 @@ class Project:
                         processed_result = {}
                         
                         doc_csv = StringIO(sections[0].strip())
-                        doc_df = pd.read_csv(doc_csv, keep_default_na=False)
+                        try:
+                            doc_df = pd.read_csv(doc_csv, keep_default_na=False)
+                        except pd.errors.ParserError as e:
+                            print(f"Error processing Document Extraction CSV: {str(e)}")
+                            continue
                         
                         chat_csv = StringIO(sections[1].strip())
-                        chat_df = pd.read_csv(chat_csv, keep_default_na=False)
+                        try:
+                            chat_df = pd.read_csv(chat_csv, keep_default_na=False)
+                        except pd.errors.ParserError as e:
+                            print(f"Error processing Chatbot CSV: {str(e)}")
+                            continue
                         
                         processed_result = {
                             f"{function_name}": pd.concat([

google_drive.py

@@ -432,11 +432,20 @@ def upload_to_gdrive(project_name, progress=gr.Progress()):
             if project.mandays_results:
                 for result in project.mandays_results:
                     function_name = result['function_name']
-                    df = pd.DataFrame(result['result'])
-                    if not df.empty:
-                      csv_content = df.to_csv(index=False)
-                    upload_content(service, subfolder_id, f"{function_name}.csv", csv_content)
-                    progress(0.1, f"Uploaded {function_name}.csv")
+                    result_data = result['result']
+
+                    # Ensure result_data is a list of dictionaries
+                    if isinstance(result_data, dict) and function_name in result_data:
+                        actual_data = result_data[function_name]
+                        df = pd.DataFrame(actual_data)
+                        if not df.empty:
+                            # Ensure CSV content is correctly formatted
+                            csv_content = df.to_csv(index=False)
+                            # Upload the CSV content to Google Drive
+                            upload_content(service, subfolder_id, f"{function_name}.csv", csv_content)
+                            progress(0.1, f"Uploaded {function_name}.csv")
+                    else:
+                        print(f"Unexpected result data format for {function_name}.")
             
             if project.mvp_mandays_results:
                 for result in project.mvp_mandays_results:
@@ -449,11 +458,11 @@ def upload_to_gdrive(project_name, progress=gr.Progress()):
                             if isinstance(records, list):
                                 df = pd.DataFrame(records)
                                 if not df.empty:
-                                  csv_content = df.to_csv(index=False)
-
-                                # Upload the CSV content to Google Drive
-                                upload_content(service, subfolder_id, f"{function_name}_{section_name}.csv", csv_content)
-                                progress(0.1, f"Uploaded {function_name}_{section_name}.csv")
+                                    # Ensure CSV content is correctly formatted
+                                    csv_content = df.to_csv(index=False)
+                                    # Upload the CSV content to Google Drive
+                                    upload_content(service, subfolder_id, f"{function_name}_{section_name}.csv", csv_content)
+                                    progress(0.1, f"Uploaded {function_name}_{section_name}.csv")
                             else:
                                 print(f"Unexpected data format for {section_name} in {function_name}.")
                     else:

notion.py

@@ -193,6 +193,42 @@ def process_mixed_content(content):
     
     return blocks
 
+def mandays_markdown_to_notion_blocks(markdown):
+    """Convert markdown text to Notion blocks."""
+    blocks = []
+    lines = markdown.split('\n')
+    
+    # Check if the markdown is a table
+    if lines and '|' in lines[0]:
+        # Process as a table
+        headers = [header.strip() for header in lines[0].split('|') if header.strip()]
+        for line in lines[2:]:  # Skip header and separator
+            if not line.strip():
+                continue
+            cells = [cell.strip() for cell in line.split('|') if cell.strip()]
+            if len(cells) == len(headers):
+                row = {headers[i]: cells[i] for i in range(len(headers))}
+                blocks.append({
+                    "object": "block",
+                    "type": "table_row",
+                    "table_row": {
+                        "cells": [{"type": "text", "text": {"content": cell}} for cell in cells]
+                    }
+                })
+    else:
+        # Process as regular text
+        for line in lines:
+            if line.strip():
+                blocks.append({
+                    "object": "block",
+                    "type": "paragraph",
+                    "paragraph": {
+                        "rich_text": [{"type": "text", "text": {"content": line}}]
+                    }
+                })
+    
+    return blocks
+
 def upload_blocks_to_notion(notion, page_id, blocks, chunk_size=95):
     """Upload blocks to Notion in chunks due to API limits."""
     for i in range(0, len(blocks), chunk_size):
@@ -274,37 +310,49 @@ def upload_to_notion(project_name):
             if project.mandays_results:
                 for result in project.mandays_results:
                     function_name = result['function_name']
-                    df = pd.DataFrame(result['result'])
-                    if not df.empty:
-                      markdown_content = df.to_markdown(index=False)
-                      blocks = markdown_to_notion_blocks(markdown_content)
-                    subpage = notion.pages.create(
-                        parent={"page_id": parent_page_id},
-                        properties={"title": [{"type": "text", "text": {"content": f"{function_name}_mandays"}}]}
-                    )
-                    upload_blocks_to_notion(notion, subpage["id"], blocks)
-                    print(f"Uploaded {function_name}_mandays to Notion")
-            
+                    result_data = result['result']
+
+                    # Ensure result_data is a list of dictionaries
+                    if isinstance(result_data, dict) and function_name in result_data:
+                        actual_data = result_data[function_name]
+                        df = pd.DataFrame(actual_data)
+                        if not df.empty:
+                            # Convert DataFrame to markdown
+                            markdown_content = df.to_markdown(index=False)
+                            blocks = mandays_markdown_to_notion_blocks(markdown_content)
+                            subpage = notion.pages.create(
+                                parent={"page_id": parent_page_id},
+                                properties={"title": [{"type": "text", "text": {"content": f"{function_name}_mandays"}}]}
+                            )
+                            upload_blocks_to_notion(notion, subpage["id"], blocks)
+                            print(f"Uploaded {function_name}_mandays to Notion")
+                    else:
+                        print(f"Unexpected result data format for {function_name}.")
+
             if project.mvp_mandays_results:
                 for result in project.mvp_mandays_results:
                     function_name = result['function_name']
                     result_data = result['result']
-                    
-                    df = pd.DataFrame(result_data)
+
+                    # Check if result_data is a dictionary
                     if isinstance(result_data, dict):
                         for section_name, records in result_data.items():
                             if isinstance(records, list):
                                 df = pd.DataFrame(records)
                                 if not df.empty:
-                                  markdown_content = df.to_markdown(index=False)  # Convert DataFrame to markdown
-                                  blocks = markdown_to_notion_blocks(markdown_content)
-                    
-                    subpage = notion.pages.create(
-                        parent={"page_id": parent_page_id},
-                        properties={"title": [{"type": "text", "text": {"content": f"{function_name}_mvp_mandays"}}]}
-                    )
-                    upload_blocks_to_notion(notion, subpage["id"], blocks)
-                    print(f"Uploaded {function_name}_mvp_mandays to Notion")
+                                    # Convert DataFrame to markdown
+                                    markdown_content = df.to_markdown(index=False)
+                                    blocks = mandays_markdown_to_notion_blocks(markdown_content)
+                                    subpage = notion.pages.create(
+                                        parent={"page_id": parent_page_id},
+                                        properties={"title": [{"type": "text", "text": {"content": f"{function_name}_{section_name}_mvp_mandays"}}]}
+                                    )
+                                    upload_blocks_to_notion(notion, subpage["id"], blocks)
+                                    print(f"Uploaded {function_name}_{section_name}_mvp_mandays to Notion")
+                            else:
+                                print(f"Unexpected data format for {section_name} in {function_name}.")
+                    else:
+                        print(f"Unexpected result data format for {function_name}.")
         
         except Exception as e:
             print(f"Failed to upload mandays results to Notion: {e}")

prompt_configs.py

@@ -5,8 +5,7 @@ from typing import List, Dict, Any, Optional
 class ModelType(Enum):
     O1_MINI = "o1-mini"
     GPT_4O_MINI = "gpt-4o-mini"
-    TEMP_GPT_4O_MINI = "gpt-4o-mini"
-
+    
 class UIComponentType(Enum):
     TEXTBOX = "textbox"
     MARKDOWN = "markdown"
@@ -461,20 +460,27 @@ PROMPTS = {
     "generate_intent_list": PromptConfig(
         prompt=
         """
-        You are an solution architect and project manager with 20+ years of experience in building chatbots and AI-powered systems.
-        Your task is to analyze the provided project requirement document and help me understand the complexity of the project by defining ALL possible intents and workflows for each requirement.
-        Additionally, anticipate and suggest realistic, real-life intents that might have been overlooked by the client but are critical for a robust and user-friendly chatbot. You can reference **how other chatbots in the same industry are functioning** and suggest intents that are commonly provided by competitors but may not have been explicitly mentioned by the client. List down these suggestion in one seperate table.
+        You are a Solution Architect and Project Manager with over 20 years of experience in designing AI-powered chatbots and automation systems. Your task is to analyze the provided Project Requirement Document and generate a comprehensive list of intents and workflows that the chatbot must support.
+        The output should focus only on relevant functional intents and workflows that directly impact the chatbot's operations, excluding generic or redundant categories like company overview.
+        Additionally, anticipate potential real-world intents that may have been overlooked by the client but are critical for a robust and user-friendly chatbot. You may reference competitor chatbots in the same industry to suggest missing functionalities.
         
-        Instruction:
-        1. **Break Down Requirements**: Identify all the client requirements from the document.
-        2. **Define ALL Possible Intents and Workflows**: For each requirement, list ALL possible intents and their corresponding workflows.  - Use "→" to represent the flow between steps.
-        - Provide your analysis in a clear, highly readable and structured table format. The intents to consider are:
-        - Simple
-        - Complex
-        - Multi-Step
-        - Single-Step
-        - Fallback.Focus on business-centric fallback (e.g., "Order Management Fallback" should address specific order-related issues like invalid SKU, payment failure, or inventory unavailability)
-        - Others (if applicable)
+        Instructions:
+        1. Identify All Requirements
+        Carefully analyze the Project Requirement Document to extract all functionalities and pain points that need to be addressed.
+        
+        2. Define ALL Possible Intents and Workflows
+        For each requirement, list all possible intents and categorize them into one of the following types:
+        - Simple: Single-turn interactions (e.g., checking order status).
+        - Complex: Multi-step interactions requiring conditional logic.
+        - Multi-Step: Sequential flows involving multiple confirmations (e.g., creating a new purchase order).
+        - Single-Step: One-shot interactions requiring minimal processing.
+        - Fallback: Business-centric error handling (e.g., invalid SKU, payment failure, inventory unavailability).
+        - Other: Any additional relevant categories.
+        
+        3. Anticipate Overlooked Intents
+        - Identify missing but critical intents based on industry best practices.
+        - Reference how competitor chatbots handle similar functionalities.
+        - Directly integrate these missing intents into the main intent list.
         
         Output Format:
         Present the analysis in a tabular format with the following structure:
@@ -528,7 +534,7 @@ PROMPTS = {
         
         Tech Stack:
         Backend: FastAPI, Python
-        Chatbot: Chatbot Builder , COZE , Yellow.ai
+        Chatbot: Chatbot Builder , COZE , Yellow.ai (STRICTLY ONLY if the project involves chatbot functionality)
         Infrastructure: AWS, PostgreSQL, Redis, Docker, Alembic
         
         Output Format:
@@ -565,7 +571,7 @@ PROMPTS = {
     "generate_page_dev_components": PromptConfig(
         prompt=
         """
-        as a Senior Software Architect with 20+ years of experience, you are tasked to generate a detailed, actionable, and project-specific component list exclusively for the development phase of the project. The list must align with the project's goals, technical stack, and compliance requirements as outlined in the provided Project Requirement Document (PRD), ensuring granularity and specificity.
+        As a Senior Software Architect with 20+ years of experience, you are tasked to generate a detailed, actionable, and project-specific component list exclusively for the development phase of the project. The list must align with the project's goals, technical stack, and compliance requirements as outlined in the provided Project Requirement Document (PRD), ensuring granularity and specificity.
         
         **Specific Requirements:**
         1. Extract relevant **granular components** from the PRD that reflect the tasks and deliverables unique to this project.
@@ -1045,39 +1051,63 @@ PROMPTS = {
     "generate_hybrid_plan_test_mandays": PromptConfig(
         prompt=
         """
-        You are an experienced project manager tasked to create a detailed task breakdown for a Hybrid project involving both Document Extraction and Chatbot functionalities. The project involves planning and testing components related to document processing, extraction, user interactions, and conversational workflows.
+        You are an experienced project manager creating a detailed task breakdown for a Hybrid project involving Document Extraction and Chatbot functionalities.
         
         Objective:
-        Generate structured CSV outputs with manday estimates for each planning and testing component, separated into Document Extraction and Chatbot sections.
+        Generate structured CSV outputs with manday estimates for planning and testing components, strictly separated into Document Extraction and Chatbot sections.
         
-        Instructions:
-        1. Input:
-           - Use the planning and testing component list to identify all components and subcomponents.
-           - The hierarchy of the document is: Phase -> Component -> Subcomponent -> Task.
+        Strict Requirements:
+        1. Input Processing:
+        - Use the component list with hierarchy: Phase -> Component -> Subcomponent -> Task
+        - Maintain all original components - never omit any, even if mandays=0
         
         2. Manday Estimation:
-           - Assign manday estimates for each component or subcomponent based on complexity and effort required, ranging from 0.2 to 5 days.
-           - Ensure estimates account for real-world complexity, potential delays, and complications.
-        
-        3. Output Format Requirements:
-           - Generate TWO separate CSV files:
-             - First, for the Document Extraction section:
-               - Columns: "component, mandays, description".
-               - Description must include deliverables and outcomes.
-             - Second, for the Chatbot section:
-               - Columns: "component, subcomponent, mandays, description".
-               - Subcomponents must be clearly listed under each component.
-               - Description must include deliverables and outcomes.
-           - Clearly indicate Section Breaks between the two files by including:
-               ----SECTION BREAK----
-        
-        4. Output:
-           - Return **ONLY** the CSV content, no code blocks or additional text.
-           - Ensure all rows have all columns filled.
-           - Numeric values should not be quoted.
-           - Text values must be enclosed in double quotes.
-           - No empty rows or missing values.
-           - Omit the ``` code guards.
+        - Assign mandays from 0.2 to 5 days per component/subcomponent
+        - Base estimates on:
+        * Complexity (simple=0.2-1, medium=1-3, complex=3-5)
+        * Required effort
+        * Real-world contingencies
+        
+        3. Formatting Rules:
+        - TWO distinct CSV sections separated by:
+        ----SECTION BREAK----
+        - Document Extraction section (3 columns):
+        "component","mandays","description"
+        - Chatbot section (4 columns):
+        "component","subcomponent","mandays","description"
+        - All descriptions must include specific deliverables/outcomes
+        
+        4. Output Validation:
+        - Document Extraction: Must have exactly 3 columns
+        - Chatbot: Must have exactly 4 columns
+        - No duplicate components/subcomponents
+        - No empty cells - all columns must be populated
+        - Numbers unquoted, text double-quoted
+        - No markdown (```) or additional text
+        - Always use period decimal (0.5 not 0,5)
+        
+        5. Error Prevention:
+        - If any component lacks details, use "TBD" in description
+        - If unsure about mandays, use 0.5 as default
+        - Never return partial/incomplete data
+        
+        Output Example:
+        "component","mandays","description"
+        "Document Processing Setup",2,"Configure OCR engines and validation rules"
+        "Field Extraction Framework",3,"Build template matching system for key fields"
+        
+        ----SECTION BREAK----
+        
+        "component","subcomponent","mandays","description"
+        "Conversational UI","Dialog Flow Design",4,"Design 10 core conversation paths with validation"
+        "NLU Integration","Intent Classification",3,"Train model on 50+ sample utterances"
+        
+        Return ONLY the CSV data with section break - no headers, explanations, or additional text of any kind.
+        - No freeform text outside CSV
+        - No markdown backticks (```)
+        - No incomplete rows
+        - No unescaped quotes
+        - No comma-separated lists in descriptions
         """,
         inputs=["generated_plan_test_components"],
         outputs=["generated_plan_test_mandays"],
@@ -1319,14 +1349,17 @@ PROMPTS = {
            - **MVP Timeline Constraint:** Ensure the final total mandays do not exceed the MVP timeline.
         6. **Justify Adjustments:** Provide a brief explanation for any adjustments made to the mandays, ensuring they align with the timeline and maintain the MVP's core functionality.
         
-        Output Format Requirements:
-        - **Separate Planning/Testing Components and Development Components:**
-          - Planning/Testing Components:
-            component,mandays,description,priority
-            "Requirements Analysis",0,"Critical user requirements and system specifications","High"
-          - Development Components:
-            component,subcomponent,mandays,description,priority
-            "Frontend","Document Upload Interface",3,"Essential for core functionality of automated document processing","High"
+        Final Output Format Requirements (Strictly Follow):
+        1. **Planning/Testing Components (CSV):**  
+           ```csv
+           component,mandays,description,priority
+           "Requirements Analysis",0,"Critical user requirements","High"
+           ```
+        2. **Development Components (CSV):** 
+           ```csv
+           component,subcomponent,mandays,description,priority
+           "Frontend","Document Upload",3,"Essential UI for uploads","High"
+           ```
         - Include the "Priority" column for all components.
         - Include the total mandays for the revised plan and confirm whether it fits within the MVP timeline.
         - Ensure the output is concise and actionable.
@@ -1404,17 +1437,22 @@ PROMPTS = {
         8. Justify Adjustments:
         - Provide a brief explanation for any adjustments made to the mandays, ensuring they align with the timeline and maintain the MVP's core functionality.
         
-        Output Format Requirements:
-        - **Separate Planning/Testing Components , Development Components and MVP Intents:**
-        - Planning/Testing Components:
-          component,mandays,description,priority
-          "Requirements Analysis",0,"Critical user requirements and system specifications","High"
-        - Development Components:
-          component,subcomponent,mandays,description,priority
-          "Frontend","Document Upload Interface",3,"Essential for core functionality of automated document processing","High"
-        - MVP Intents:
-          intent_type,intent,workflow,mandays
-          "Single-Step","Create New Order","1. User initiates order creation → 2. Extract order details from user input → 3. Save order to database → 4. Confirm creation to user",0.3
+        Final Output Format Requirements (Strictly Follow):
+        1. **Planning/Testing Components (CSV):**  
+           ```csv
+           component,mandays,description,priority
+           "Requirements Analysis",0,"Critical user requirements","High"
+           ```
+        2. **Development Components (CSV):** 
+           ```csv
+           component,subcomponent,mandays,description,priority
+           "Frontend","Document Upload",3,"Essential UI for uploads","High"
+           ```
+        3. **MVP Intents (CSV):**
+           ```csv
+           intent_type,intent,workflow,mandays
+           "Single-Step","Create New Order","1. User initiates order creation → 2. Extract order details → 3. Save order → 4. Confirm creation",0.3
+           ```
         - Include the "Priority" column for all components.
         - Include the total mandays for the revised plan and confirm whether it fits within the MVP timeline.
         - Ensure the output is concise and actionable.
@@ -1426,7 +1464,7 @@ PROMPTS = {
         inputs=["identified_planning_testing_components", "identified_development_components", "identified_mvp_intents", "generated_prd"],
         outputs=["revised_mandays_estimates"],
         model=ModelType.O1_MINI,
-        description="Engage MVP Mandays Recalculation",
+        description="Engage/Hybrid MVP Mandays Recalculation",
         step="Step 2 : Mandays & Quotation",
         sub_step="Step 2.3 : Recalculate MVP Mandays",
         ui={
@@ -1512,35 +1550,39 @@ PROMPTS = {
         Using the revised mandays estimates from the previous step, format the output into three clearly separated CSV sections: one for Planning/Testing Components, one for Development Components, and another for MVP Intents.
         
         Objective:
-        Structure the output to clearly delineate the two sections while maintaining the original column structure. Ensure that there are no duplicate components or subcomponents in the output.
+        Structure the output to clearly delineate the three sections while maintaining the original column structure. Ensure that there are no duplicate components or subcomponents in the output.
         
         Output Format Requirements:
-        - First Section - Planning & Testing Components:
+        1. First Section - Planning & Testing Components (CSV format):
         component,mandays,description
         "Requirements Analysis",0,"Critical user requirements and system specifications"
         
-        - Second Section - Development Components:
+        2. Second Section - Development Components (CSV format):
         component,subcomponent,mandays,description
         "Backend","Core API Development",3,"Essential API endpoints for basic functionality"
         
-        - Third Section - MVP Intents:
+        3. Third Section - MVP Intents (CSV format):
         intent_type,intent,workflow,mandays
-        "Single-Step","Create New Order","1. User initiates order creation → 2. Extract order details from user input → 3. Save order to database → 4. Confirm creation to user",0.3
-        
-        Important:
-        - Each section must maintain its original column structure.
-        - Sections MUST be separated by the marker: "----SECTION BREAK----".
-        - Include ALL the components and intents.
-        - No empty rows or missing values.
-        - Text values must be in double quotes.
-        - Numbers must not be in quotes.
-        
-        Return only the CSV content with the section break, no additional text or explanations.
+        "Single-Step","Create New Order","1. User initiates order creation → 2. Extract order details → 3. Save order → 4. Confirm creation",0.3
+        
+        Strict Requirements:
+        - Output MUST be in pure CSV format only, with no additional text, headers, or markdown indicators like ```plaintext```
+        - Sections MUST be separated exactly by: ----SECTION BREAK----
+        - Each section must maintain its specified column structure
+        - Include ALL components and intents without duplication
+        - No empty rows or missing values allowed
+        - All text values must be in double quotes
+        - Numbers must not be in quotes
+        - Ensure the Development Components section has all four columns
+        - Ensure the MVP Intents section has all four columns
+        - The section break must be on its own line with no other content
+        
+        Return only the CSV content with the section breaks, absolutely no additional text or explanations before, between, or after the sections.
         """,
         inputs=["revised_mandays_estimates"],
         outputs=["generated_MVP_mandays"],
         model=ModelType.O1_MINI,
-        description="Generate Engage MVP Mandays",
+        description="Generate Engage/Hybrid MVP Mandays",
         step="Step 2 : Mandays & Quotation",
         sub_step="Step 2.4 : Generate MVP Mandays",
         ui={