Update app.py

app.py

@@ -8,13 +8,12 @@ from pptx.util import Pt, Inches
 from pptx.enum.text import PP_ALIGN
 from pptx.dml.color import RGBColor
 from reportlab.lib.pagesizes import letter
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.lib import colors
+from reportlab.pdfgen import canvas
 from reportlab.lib.units import inch
-from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY
+from reportlab.lib import colors
 from dotenv import load_dotenv
 import re
+import textwrap
 
 # Load environment variables
 load_dotenv()
@@ -39,68 +38,216 @@ def generate_proposal(description, project_type=None):
     """Generate a proposal from a description using OpenRouter API"""
     
     # Create a better prompt with example formatting and detailed instructions
-    system_prompt = """You are a professional business proposal writer with expertise in creating detailed, well-structured project proposals. 
+    system_prompt = """You are a professional technical documentation writer with expertise in creating detailed, well-structured requirements and proposal documents.
     
-Your proposals are comprehensive, highly detailed, and follow a clear structure with proper formatting. Each section should include substantial content with specific details, bullet points where appropriate, and professional language.
+Your documents are comprehensive, highly detailed, and follow a clear structure with proper formatting. Each section should include substantial content with specific details, bullet points, and professional technical language.
 
 Make sure to:
 1. Include proper formatting with section headings in bold
-2. Add bullet points for lists and key points
-3. Include realistic timelines, budgets, and team structures
-4. Provide concrete, specific details rather than generic statements
-5. Maintain a professional tone throughout
-6. Create content that looks like it was written by human experts in the field
+2. Use bullet points (● symbol) for listing features and requirements
+3. Organize content into logical sections and subsections
+4. Provide concrete, specific technical details rather than generic statements
+5. Maintain a professional, technical tone throughout
+6. DO NOT include timelines, budgets, or pricing information
+7. Format the document to look like a formal technical requirements document
+8. Focus on functional requirements, technical specifications, and feature details
 
-The proposal must be highly detailed, professionally formatted, and ready for presentation to stakeholders.
+The document must be highly detailed, professionally formatted, and ready for presentation to technical stakeholders.
 """
 
-    example_format = """**Project Proposal: [Title based on description]**
+    # For SaaS Performance Platform, use a specific template based on the provided document
+    if project_type == "saas_performance":
+        example_format = """**[Title based on description]**
+
+**Introduction:**
+A comprehensive explanation of the project goals, purpose, and overview in 2-3 paragraphs. Describe the key benefits and intended outcomes without mentioning timelines or budgets.
+
+**Functional Requirements:**
+
+**User Authentication and Role Management:**
+● [Feature point 1]
+● [Feature point 2]
+● [Feature point 3]
+
+**Dashboard and Analytics:**
+● [Feature point 1]
+● [Feature point 2]
+● [Feature point 3]
+
+**Evaluation Framework Builder:**
+● [Feature point 1]
+● [Feature point 2]
+● [Feature point 3]
+
+**Data Input and Rating Engine:**
+● [Feature point 1]
+● [Feature point 2]
+● [Feature point 3]
+
+**Progress Tracking Module:**
+● [Feature point 1]
+● [Feature point 2]
+● [Feature point 3]
+
+**Reporting and Exporting:**
+● [Feature point 1]
+● [Feature point 2]
+● [Feature point 3]
+
+**Notifications:**
+● [Feature point 1]
+
+**Permission and Access Management:**
+● [Feature point 1]
+● [Feature point 2]
+
+**Audit Log and Activity Tracking:**
+● [Feature point 1]
+● [Feature point 2]
+
+**Modules:**
+● [Module 1]
+● [Module 2]
+● [Module 3]
+● [Module 4]
+● [Module 5]
+● [Module 6]
+● [Module 7]
+● [Module 8]
+
+**User Roles and Permissions:**
+
+**[Role Type 1]:**
+● [Permission 1]
+● [Permission 2]
+
+**[Role Type 2]:**
+● [Permission 1]
+● [Permission 2]
+● [Permission 3]
+
+**[Role Type 3]:**
+● [Permission 1]
+● [Permission 2]
+
+**[Role Type 4]:**
+● [Permission 1]
+● [Permission 2]
+● [Permission 3]
+
+**Technology Stack:**
+● [Technology Category 1]: [Specific technologies]
+● [Technology Category 2]: [Specific technologies]
+● [Technology Category 3]: [Specific technologies]
+● [Technology Category 4]: [Specific technologies]
+● [Technology Category 5]: [Specific technologies]
+● [Technology Category 6]: [Specific technologies]
+● [Technology Category 7]: [Specific technologies]
+● [Technology Category 8]: [Specific technologies]
+● [Technology Category 9]: [Specific technologies]
+● [Technology Category 10]: [Specific technologies]
 
-**1. Executive Summary**
-A comprehensive 3-5 paragraph summary that clearly articulates the project's purpose, key features, benefits, timeline, budget range, and expected outcomes. Include specific metrics and goals.
+**Conclusion:**
+A final summary of the proposed system and its benefits in 1-2 paragraphs. Emphasize how the solution will meet the needs described without mentioning timelines or costs."""
+    else:
+        # General format for other project types
+        example_format = """**[Title based on description]**
 
-**2. Project Background**
-Detailed explanation of the current situation, market analysis, problems being addressed, and the opportunity. Include specific industry trends, challenges, and the gap this project fills.
+**Introduction:**
+A comprehensive explanation of the project goals, purpose, and overview in 2-3 paragraphs. Describe the key benefits and intended outcomes without mentioning timelines or budgets.
 
-**3. Goals and Objectives**
-Clearly separated primary goals (broader aims) and specific objectives (measurable targets). Use bullet points for clarity, with each objective being SMART (Specific, Measurable, Achievable, Relevant, Time-bound).
+**Functional Requirements:**
 
-**4. Methodology and Approach**
-Detailed explanation of the implementation approach, including specific phases, methodologies, technologies, and frameworks to be used. Outline the specific steps that will be taken.
+**[Key Feature Area 1]:**
+● [Feature point 1]
+● [Feature point 2]
+● [Feature point 3]
 
-**5. Timeline**
-Specific weekly breakdown of the project with clear milestones, deliverables, and dependencies. Include duration estimates and key decision points.
+**[Key Feature Area 2]:**
+● [Feature point 1]
+● [Feature point 2]
+● [Feature point 3]
 
-**6. Budget Considerations**
-Detailed budget breakdown with percentages, actual figures, and justifications for each expense category. Include contingency planning and ROI estimates where applicable.
+**[Key Feature Area 3]:**
+● [Feature point 1]
+● [Feature point 2]
+● [Feature point 3]
 
-**7. Expected Outcomes**
-Comprehensive list of both tangible and intangible outcomes, specific metrics for success, and long-term benefits. Include KPIs that will be used to measure success.
+**[Key Feature Area 4]:**
+● [Feature point 1]
+● [Feature point 2]
+● [Feature point 3]
 
-**8. Team and Resources**
-Specific team composition with roles, responsibilities, and experience levels. Include external resources, tools, and infrastructure requirements.
+**System Architecture:**
+● [Architecture Component 1]
+● [Architecture Component 2]
+● [Architecture Component 3]
 
-**9. Risk Assessment**
-Detailed identification of potential risks, probability and impact ratings, and specific mitigation strategies for each risk. Include contingency plans.
+**Technical Specifications:**
+● [Technical Requirement 1]
+● [Technical Requirement 2]
+● [Technical Requirement 3]
 
-**10. Conclusion**
-Powerful closing that reinforces the value proposition, summarizes key benefits, and includes a clear call to action."""
+**Security Requirements:**
+● [Security Feature 1]
+● [Security Feature 2]
+● [Security Feature 3]
 
-    # Create a project type specific prompt if provided
+**Integration Requirements:**
+● [Integration Point 1]
+● [Integration Point 2]
+● [Integration Point 3]
+
+**User Types and Permissions:**
+
+**[User Type 1]:**
+● [Permission 1]
+● [Permission 2]
+
+**[User Type 2]:**
+● [Permission 1]
+● [Permission 2]
+
+**[User Type 3]:**
+● [Permission 1]
+● [Permission 2]
+
+**Technology Stack:**
+● [Technology Area 1]: [Specific technologies]
+● [Technology Area 2]: [Specific technologies]
+● [Technology Area 3]: [Specific technologies]
+● [Technology Area 4]: [Specific technologies]
+
+**Conclusion:**
+A final summary of the proposed system and its benefits in 1-2 paragraphs. Emphasize how the solution will meet the needs described without mentioning timelines or costs."""
+
+    # Create a project type specific instruction
     project_specific_prompt = ""
     if project_type == "saas_performance":
-        project_specific_prompt = """For this SaaS Performance Evaluation Platform, be sure to include:
-- Multi-tenant architecture with role-based access control details
-- User authentication and authorization specifics
-- Dashboard and analytics features with visualization options
-- Evaluation framework customization capabilities
-- Data input methods and integration with external systems
-- Performance tracking and reporting mechanisms
-- Specific technology stack recommendations with justifications
-- Security measures for protecting sensitive performance data
-- Scalability and performance considerations"""
+        project_specific_prompt = """
+Format the document to precisely match the example provided. For this SaaS Performance Evaluation Platform:
+
+1. DO NOT include any sections about budget, timeline, team structure, or pricing
+2. Structure the document exactly like the provided example with these specific sections:
+   - Introduction
+   - Functional Requirements (with all subsections as shown)
+   - User Roles and Permissions (with all user types)
+   - Technology Stack
+   - Conclusion
+3. Use bullet points with the ● symbol for all feature lists
+4. Include specific technical details about:
+   - Multi-tenant architecture with role-based access control
+   - User authentication and authorization
+   - Dashboard and analytics features with visualization options
+   - Evaluation framework capabilities
+   - Data input methods and rating systems
+   - Reporting and exporting functions
+   - Specific technology recommendations
+5. Maintain a formal, technical tone throughout the document
+6. Format all section headings in bold with a colon, like: "**Section Name:**"
+"""
     
-    prompt = f"""Create a detailed project proposal based on the following description. Format it exactly like the example format provided, with bold section headings and proper structure.
+    prompt = f"""Create a detailed technical requirements document based on the following description. Format it exactly like the example format provided, with bold section headings and proper structure.
 
 {example_format}
 
@@ -108,7 +255,8 @@ Project Description: {description}
 
 {project_specific_prompt}
 
-Create a complete, professionally formatted project proposal that could be presented directly to stakeholders. Make each section highly detailed and specific."""
+Create a complete, professionally formatted technical requirements document that resembles a formal functional specification. DO NOT include any sections about budget, timeline, team structure, or pricing. Focus entirely on functional and technical requirements.
+"""
 
     try:
         completion = client.chat.completions.create(
@@ -127,7 +275,7 @@ Create a complete, professionally formatted project proposal that could be prese
                     "content": prompt
                 }
             ],
-            temperature=0.5,  # Lower temperature for more consistent results
+            temperature=0.4,  # Lower temperature for more consistent, formal results
             max_tokens=4500
         )
         
@@ -140,18 +288,23 @@ Create a complete, professionally formatted project proposal that could be prese
 
 def extract_title(proposal):
     """Extract the title from the proposal"""
-    # Try to match the exact format first
+    # Try to match the exact format first - standard format
     title_match = re.search(r"\*\*Project Proposal: (.*?)\*\*", proposal)
     if title_match:
         return title_match.group(1)
     
+    # Try to match the requirements document format - just the title
+    title_match = re.search(r"\*\*(.*?)\*\*", proposal)
+    if title_match:
+        return title_match.group(1)
+    
     # Fallback pattern for more flexibility
-    title_match = re.search(r"\*\*\s*(?:Project Proposal|Proposal|Title):\s*(.*?)\s*\*\*", proposal, re.IGNORECASE)
+    title_match = re.search(r"\*\*\s*(?:Project Proposal|Proposal|Title|Requirements Document):\s*(.*?)\s*\*\*", proposal, re.IGNORECASE)
     if title_match:
         return title_match.group(1)
     
     # If no title found, use a generic one
-    return "Project Proposal"
+    return "Requirements Document"
 
 def create_pdf(proposal, output_path="proposal.pdf"):
     """Create a PDF document from the proposal"""
@@ -241,78 +394,106 @@ def create_slides(proposal):
         
         # Add title slide
         title_slide = prs.slides.add_slide(title_slide_layout)
-        title_slide.shapes.title.text = f"Project Proposal: {title}"
+        title_slide.shapes.title.text = title
         subtitle = title_slide.placeholders[1]
-        subtitle.text = "Professional Project Proposal"
+        subtitle.text = "Requirements Document"
         
-        # List of sections to look for
-        sections = [
-            "Executive Summary", 
-            "Project Background", 
-            "Goals and Objectives", 
-            "Methodology and Approach", 
-            "Timeline", 
-            "Budget Considerations", 
-            "Expected Outcomes", 
-            "Team and Resources", 
-            "Risk Assessment", 
-            "Conclusion"
-        ]
+        # Parse the document into sections
+        sections = []
+        current_section = None
+        current_content = []
         
-        # Extract sections using regex
-        section_matches = re.finditer(r'\*\*\d+\.\s+(.*?)\*\*\n\n(.*?)(?=\*\*\d+\.|\Z)', 
-                                    proposal, re.DOTALL)
+        # Split into paragraphs
+        paragraphs = proposal.split('\n\n')
         
-        for match in section_matches:
-            section_title = match.group(1)
-            section_content = match.group(2).strip()
+        for para in paragraphs:
+            para = para.strip()
+            if not para:
+                continue
+                
+            # Check if it's a main section header
+            if para.startswith('**') and para.endswith('**'):
+                # Save previous section if exists
+                if current_section and current_content:
+                    sections.append((current_section, current_content))
+                
+                # Start new section
+                current_section = para.replace('**', '')
+                current_content = []
             
-            # Add section title slide
+            # Check if it's a subsection header
+            elif para.startswith('**') and '**:' in para:
+                parts = para.split('**:', 1)
+                if len(parts) == 2:
+                    # Add as subsection with special formatting
+                    header = parts[0].replace('**', '') + ':'
+                    content = parts[1].strip()
+                    current_content.append(("subsection", header, content if content else []))
+            
+            # Regular content or bullet points
+            else:
+                current_content.append(("content", para))
+        
+        # Add the last section
+        if current_section and current_content:
+            sections.append((current_section, current_content))
+        
+        # Create slides for each section
+        for section_title, contents in sections:
+            # Skip the first section if it's the title
+            if section_title.lower() == title.lower():
+                continue
+                
+            # Section title slide
             section_slide = prs.slides.add_slide(section_title_layout)
             section_slide.shapes.title.text = section_title
             
-            # Split content into paragraphs
-            paragraphs = section_content.split('\n\n')
-            
-            # Process each paragraph
+            # Content slides
             current_slide = None
             text_frame = None
-            paragraphs_on_slide = 0
+            items_on_slide = 0
             
-            for para in paragraphs:
-                para = para.strip()
-                if not para:
-                    continue
-                
+            for content_type, *content_data in contents:
                 # Start a new slide if needed
-                if current_slide is None or paragraphs_on_slide >= 3:
+                if current_slide is None or items_on_slide >= 6:
                     current_slide = prs.slides.add_slide(content_layout)
                     current_slide.shapes.title.text = section_title
                     text_frame = current_slide.placeholders[1].text_frame
-                    paragraphs_on_slide = 0
+                    items_on_slide = 0
                 
-                # Add the paragraph
-                p = text_frame.add_paragraph()
-                
-                # Check if it's a bullet point list
-                if re.match(r'^[\*\-]', para):
-                    # Process bullet points
-                    bullet_items = re.split(r'\n[\*\-]\s+', para)
-                    for item in bullet_items:
-                        item = item.strip()
-                        if item:
-                            # Remove leading bullet if present
-                            item = re.sub(r'^[\*\-]\s+', '', item)
-                            bullet_p = text_frame.add_paragraph()
-                            bullet_p.text = item
-                            bullet_p.level = 1
-                else:
-                    p.text = para
+                if content_type == "subsection":
+                    # Add subsection header
+                    subsection_header, subsection_content = content_data
+                    p = text_frame.add_paragraph()
+                    p.text = subsection_header
+                    p.font.bold = True
+                    items_on_slide += 1
+                    
+                    # Add subsection content if any
+                    if subsection_content and isinstance(subsection_content, str):
+                        p = text_frame.add_paragraph()
+                        p.text = subsection_content
+                        items_on_slide += 1
                 
-                paragraphs_on_slide += 1
+                elif content_type == "content":
+                    para_text = content_data[0]
+                    
+                    # Check if it's a bullet list
+                    if para_text.startswith('●'):
+                        lines = para_text.split('\n')
+                        for line in lines:
+                            if line.strip():
+                                p = text_frame.add_paragraph()
+                                p.text = line.strip().replace('●', '').strip()
+                                p.level = 1
+                                items_on_slide += 1
+                    else:
+                        p = text_frame.add_paragraph()
+                        p.text = para_text
+                        items_on_slide += 1
         
         # Save the presentation
-        output_path = "proposal_slides.pptx"
+        output_path = "requirements_slides.pptx"
         prs.save(output_path)
         return output_path
     
@@ -326,90 +507,133 @@ def create_slides(proposal):
             subtitle = slide.placeholders[1]
             subtitle.text = f"An error occurred: {str(e)}\nPlease try again with a different project description."
             
-            output_path = "proposal_slides.pptx"
+            output_path = "requirements_slides.pptx"
             prs.save(output_path)
         except:
             # If even the error presentation fails, return a default path
             pass
         return output_path
 
-def process_input(description, project_type):
-    """Process the input and generate both proposal, PDF and slides"""
+def create_pdf(proposal, output_path="requirements_document.pdf"):
+    """Create a PDF document from the proposal"""
     try:
-        # Check if input is too short
-        if len(description.strip()) < 10:
-            return "Please provide a more detailed project description (at least 10 characters).", None, None
+        from reportlab.lib.pagesizes import letter
+        from reportlab.pdfgen import canvas
+        from reportlab.lib.units import inch
+        from reportlab.lib import colors
         
-        # Map project type to specific type value
-        type_value = None
-        if project_type == "SaaS Performance Platform":
-            type_value = "saas_performance"
+        # Basic PDF generation using canvas directly
+        c = canvas.Canvas(output_path, pagesize=letter)
+        width, height = letter
         
-        # Generate the proposal
-        proposal = generate_proposal(description, type_value)
+        # Add a header with company info (similar to the example)
+        c.setFont("Helvetica", 10)
+        c.drawString(1*inch, height-0.5*inch, "Generated Requirements Document")
         
-        # Create a basic PDF without any custom styles - fallback approach
-        try:
-            from reportlab.lib.pagesizes import letter
-            from reportlab.pdfgen import canvas
-            
-            # Basic PDF generation using canvas directly
-            c = canvas.Canvas("proposal.pdf", pagesize=letter)
-            width, height = letter
-            
-            # Title
-            c.setFont("Helvetica-Bold", 16)
-            c.drawCentredString(width/2, height-50, "Project Proposal")
-            
-            # Simple text rendering
-            c.setFont("Helvetica", 10)
-            y = height - 80
-            line_height = 14
-            
-            lines = proposal.split('\n')
-            for line in lines:
-                # Check for page break
-                if y < 50:
-                    c.showPage()
-                    y = height - 50
+        # Title
+        title = extract_title(proposal)
+        c.setFont("Helvetica-Bold", 14)
+        c.drawCentredString(width/2, height-1.2*inch, title)
+        
+        # Simple text rendering
+        c.setFont("Helvetica", 10)
+        y = height - 1.5*inch
+        line_height = 14
+        
+        # Process by paragraphs to handle sections better
+        paragraphs = proposal.split('\n\n')
+        
+        for paragraph in paragraphs:
+            paragraph = paragraph.strip()
+            if not paragraph:
+                continue
                 
-                # Check if it's a header (starts with **)
-                if line.startswith('**'):
-                    c.setFont("Helvetica-Bold", 12)
-                    # Remove ** markers
-                    line = line.replace('**', '')
-                else:
-                    c.setFont("Helvetica", 10)
+            # Check for page break
+            if y < 1*inch:
+                c.showPage()
+                # Add header to new page
+                c.setFont("Helvetica", 10)
+                c.drawString(1*inch, height-0.5*inch, "Generated Requirements Document")
+                y = height - 1*inch
+            
+            # Check if it's a section header (starts with **)
+            if paragraph.startswith('**') and paragraph.endswith('**'):
+                c.setFont("Helvetica-Bold", 12)
+                # Remove ** markers
+                paragraph = paragraph.replace('**', '')
+                c.drawString(1*inch, y, paragraph)
+                y -= line_height * 1.5
+            # Check if it's a subsection header (starts with ** but has more text)
+            elif paragraph.startswith('**') and '**:' in paragraph:
+                parts = paragraph.split('**:', 1)
+                if len(parts) == 2:
+                    header = parts[0].replace('**', '') + ':'
+                    c.setFont("Helvetica-Bold", 11)
+                    c.drawString(1*inch, y, header)
+                    y -= line_height * 1.2
+                    
+                    # If there's content after the header
+                    content = parts[1].strip()
+                    if content:
+                        c.setFont("Helvetica", 10)
+                        # Need to wrap this text
+                        text_object = c.beginText(1.2*inch, y)
+                        for line in textwrap.wrap(content, width=70):
+                            text_object.textLine(line)
+                            y -= line_height
+                        c.drawText(text_object)
+                        y -= line_height * 0.5
+            # Check if it's a bullet point
+            elif paragraph.startswith('●'):
+                c.setFont("Helvetica", 10)
+                # Draw the bullet
+                c.drawString(1.2*inch, y, '●')
                 
-                # Draw the line
-                if line.strip():
-                    c.drawString(50, y, line)
+                # Draw the text after the bullet with indentation
+                text = paragraph[1:].strip()
+                text_object = c.beginText(1.5*inch, y)
+                for line in textwrap.wrap(text, width=60):
+                    text_object.textLine(line)
                     y -= line_height
-            
-            c.save()
-            pdf_path = "proposal.pdf"
-        except Exception as pdf_error:
-            print(f"Error creating PDF: {pdf_error}")
-            pdf_path = None
+                c.drawText(text_object)
+                y -= line_height * 0.3
+            else:
+                # Regular paragraph
+                c.setFont("Helvetica", 10)
+                # Need to wrap this text
+                text_object = c.beginText(1*inch, y)
+                for line in textwrap.wrap(paragraph, width=70):
+                    text_object.textLine(line)
+                    y -= line_height
+                c.drawText(text_object)
+                y -= line_height * 0.5
         
-        # Create the slides
-        try:
-            ppt_path = create_slides(proposal)
-        except Exception as ppt_error:
-            print(f"Error creating slides: {ppt_error}")
-            ppt_path = None
+        # Add a footer with page number
+        c.setFont("Helvetica", 8)
+        c.drawCentredString(width/2, 0.5*inch, "Page 1")
         
-        return proposal, pdf_path, ppt_path
+        c.save()
+        return output_path
     except Exception as e:
-        error_message = f"An error occurred: {str(e)}\nPlease try again with a different project description."
-        print(f"Error in process_input: {e}")
-        return error_message, None, None
+        print(f"Error creating PDF: {e}")
+        # Create an even simpler emergency PDF
+        try:
+            c = canvas.Canvas(output_path, pagesize=letter)
+            width, height = letter
+            c.setFont("Helvetica-Bold", 14)
+            c.drawString(1*inch, height-1*inch, "Requirements Document")
+            c.setFont("Helvetica", 10)
+            c.drawString(1*inch, height-1.5*inch, "Error formatting document. Please see text version.")
+            c.save()
+        except Exception as inner_e:
+            print(f"Error creating emergency PDF: {inner_e}")
+        return output_path
 
 # Create Gradio interface
 def create_interface():
-    with gr.Blocks(title="Professional Project Proposal Generator") as app:
-        gr.Markdown("# Professional Project Proposal Generator")
-        gr.Markdown("Generate comprehensive, professionally formatted project proposals with PDF and PowerPoint exports.")
+    with gr.Blocks(title="Requirements Document Generator") as app:
+        gr.Markdown("# Technical Requirements Document Generator")
+        gr.Markdown("Generate comprehensive, professionally formatted technical requirements documents with PDF and PowerPoint exports.")
         
         with gr.Row():
             with gr.Column(scale=1):
@@ -422,10 +646,10 @@ def create_interface():
                 project_type = gr.Dropdown(
                     label="Project Type",
                     choices=["General Project", "SaaS Performance Platform"],
-                    value="General Project"
+                    value="SaaS Performance Platform"
                 )
                 
-                generate_button = gr.Button("Generate Proposal", variant="primary")
+                generate_button = gr.Button("Generate Requirements Document", variant="primary")
                 
                 # Examples
                 examples = gr.Examples(
@@ -440,8 +664,8 @@ def create_interface():
             with gr.Column(scale=2):
                 output_tabs = gr.Tabs()
                 with output_tabs:
-                    with gr.TabItem("Proposal Text"):
-                        proposal_output = gr.Textbox(label="Generated Proposal", lines=25)
+                    with gr.TabItem("Document Text"):
+                        proposal_output = gr.Textbox(label="Generated Document", lines=25)
                     with gr.TabItem("Documents"):
                         with gr.Row():
                             pdf_output = gr.File(label="PDF Document")