Update app.py via AI Editor

app.py

@@ -1,721 +1,232 @@
-import base64
-import io
 import os
+import base64
+import logging
 import threading
-import time
-from typing import List, Tuple
-import re
 import pandas as pd
+from io import BytesIO, StringIO
 from docx import Document
-from io import BytesIO
+from PyPDF2 import PdfReader
 import dash
 import dash_bootstrap_components as dbc
-from dash import html, dcc, Input, Output, State, ctx, dash_table, callback_context
-import google.generativeai as genai
-from docx import Document
-from docx.shared import Pt
-from docx.enum.style import WD_STYLE_TYPE
-from PyPDF2 import PdfReader
-from io import StringIO
-
-# Initialize Dash app
-app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
-
-# Configure Gemini AI
-genai.configure(api_key=os.environ["GEMINI_API_KEY"])
-model = genai.GenerativeModel('gemini-2.5-pro-preview-03-25')
-
-def process_document(contents: str, filename: str) -> str:
+from dash import html, dcc, Input, Output, State, dash_table, callback_context
+import anthropic
+
+logging.basicConfig(level=logging.INFO)
+ANTHROPIC_KEY = os.environ.get("ANTHROPIC_API_KEY", "")
+anthropic_client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)
+CLAUDE3_SONNET_MODEL = "claude-3-7-sonnet-20250219"
+CLAUDE3_MAX_CONTEXT_TOKENS = 200_000
+CLAUDE3_MAX_OUTPUT_TOKENS = 64_000
+
+document_types = {
+    "Shred": "Ignore all other instructions and generate only requirements spreadsheet of the Project Work Statement (PWS) identified by action words like shall, will, perform etc. by pws section, requirement.  Do not write as if you're responding to the proposal.  Its a spreadsheet to distill the requirements, not microhealth's approach",
+    "Pink": "Create a highly detailed Pink Team document based on the PWS outline.  Your goal is to be compliant and compelling.  Focus on describing the approach and how it will be done, the steps, workflow, people, processes and technology based on well known industry standards to accomplish the task.  Be sure to demonstrate innovation.",
+    "Pink Review": "Ignore all other instructions and generate and evaluate compliance of the Pink Team document against the requirements and output only a spreadsheet of non compliant findings by pws number, the goal of that pws section, what made it non compliant and your recommendations for recovery. you must also take into account section L&M of the document which is the evaluation criteria to be sure we address them.",
+    "Red": "Produce a  highly detailed Red Team document based on the Pink Review by pws sections. Your goal is to be compliant and compelling by recovering all the findings in Pink Review. Focus on describing the approach and how it will be done, the steps, workflow, people, processes and technology to accomplish the task. Be sure to refer to research that validates the approach and cite sources with measurable outcomes",
+    "Red Review": "Ignore all other instructions and generate and evaluate compliance of the Red Team document against the requirements and output a only a spreadsheet of non compliant findings by pws number, the goal of that pws section, what made it non compliant and your recommendations for recovery. you must also take into account section L&M of the document which is the evaluation criteria to be sure we address them",
+    "Gold": "Create a highly detailed Gold Team document based on the PWS response by pws sections. Your goal is to be compliant and compelling by recovering all the findings in Red Review.  Focus on describing the approach and how it will be done, the steps, workflow, people, processes and technology to accomplish the task. Be sure to refer to research that validates the approach and cite sources with measurable outcomes and improve on innovations of the approach",
+    "Gold Review": "Ignore all other instructions and generate and perform a final compliance review against the requirements and output only a spreadsheet of non compliant findings by pws number, the goal of that pws section, what made it non compliant and your recommendations for recovery. you must also take into account section L&M of the document which is the evaluation criteria to be sure we address them",
+    "Virtual Board": "Ignore all other instructions and generate and based on the requirements and in particular the evaulation criteria, you will evaluate the proposal as if you were a contracting office and provide section by section evaluation as unsatisfactory, satisfactory, good, very good, excellent and why and produce only spreadsheet",
+    "LOE": "Ignore all other instructions and generate and generate a Level of Effort (LOE) breakdown and produce only spreadsheet"
+}
+
+def process_document(contents, filename):
     content_type, content_string = contents.split(',')
     decoded = base64.b64decode(content_string)
-    
-    try:
-        if filename.lower().endswith('.docx'):
-            doc = Document(BytesIO(decoded))
-            text = "\n".join([para.text for para in doc.paragraphs])
-            return text
-        elif filename.lower().endswith('.pdf'):
-            pdf = PdfReader(BytesIO(decoded))
-            text = ""
-            for page in pdf.pages:
-                text += page.extract_text()
-            return text
-        else:
-            return f"Unsupported file format: {filename}. Please upload a PDF or DOCX file."
-    except Exception as e:
-        return f"Error processing document: {str(e)}"
-
-def generate_loe(document: str, is_file: bool = False) -> Tuple[str, pd.DataFrame]:
-    prompt = f"""
-    Analyze the following document and provide a Level of Effort (LOE) breakdown:
-    Document:
-    {document}
-    For each section header in the document:
-    1. Identify each and every task to be completed from the document from each heading
-    2. Determine the appropriate labor categories for each task
-    3. Generously Over Estimate the number of hours required for each labor category to complete the task as management reserve is needed
-    Provide a detailed breakdown and then summarize the information in a tabular format with the following columns:
-    - Task Summary
-    - Labor Categories
-    - Hours per Labor Category
-    - Total Hours
-    Present the detailed breakdown first, followed by the summary table.
-    Ensure the table is properly formatted with | as column separators and a header row.
-    """
-    response = model.generate_content(prompt)
-    response_text = response.text
-    
-    # Extract the table from the response
-    table_start = response_text.find("| Task Summary |")
-    table_end = response_text.find("\n\n", table_start)
-    table_text = response_text[table_start:table_end]
-    
-    # Convert the table to a pandas DataFrame
-    try:
-        if not table_text.strip():
-            raise pd.errors.EmptyDataError("No table found in the response")
-        df = pd.read_csv(StringIO(table_text), sep='|', skipinitialspace=True).dropna(axis=1, how='all')
-        df.columns = df.columns.str.strip()
-    except pd.errors.EmptyDataError:
-        # If no table is found or it's empty, create a default DataFrame
-        df = pd.DataFrame(columns=['Task Summary', 'Labor Categories', 'Hours per Labor Category', 'Total Hours'])
-        response_text += "\n\nNote: No detailed LOE table could be generated from the AI response."
-    
-    return response_text, df
-    
-    # Convert the table to a pandas DataFrame
-    try:
-        if not table_text.strip():
-            raise pd.errors.EmptyDataError("No table found in the response")
-        df = pd.read_csv(StringIO(table_text), sep='|', skipinitialspace=True).dropna(axis=1, how='all')
-        df.columns = df.columns.str.strip()
-    except pd.errors.EmptyDataError:
-        # If no table is found or it's empty, create a default DataFrame
-        df = pd.DataFrame(columns=['Task Summary', 'Labor Categories', 'Hours per Labor Category', 'Total Hours'])
-        response_text += "\n\nNote: No detailed LOE table could be generated from the AI response."
-    
-    return response_text, df
-
-def generate_outline(text: str, instructions: str) -> str:
-    prompt = f"""
-    Analyze the following Project Work Statement (PWS) and create an outline 
-    focusing on sections the indicate specific tasks and L&M (for compliance and writing guide). Extract the main headers, subheaders, and specific 
-    requirements in each section. Pay special attention to requirements indicated 
-    by words like "shall", "will", "must", and similar imperative language.
-    Additional instructions: {instructions}
-    Document text:
-    {text}
-    Provide the outline in a structured format, clearly highlighting the specific 
-    requirements and their associated sections.
-    """
-    response = model.generate_content(prompt)
-    return response.text
-
-def generate_pink_team_document(outline: str, instructions: str) -> str:
-    prompt = f"""
-    Based on the following outline of a Project Work Statement (PWS):
-    {outline}
-    Additional instructions: {instructions}
-    Create a detailed response document as if MicroHealth is responding to this PWS. 
-    Follow these guidelines:
-    1. Use Wikipedia style writing with active voice.  Be firm with the approach, no soft words like could be, may be, should, might.  Use definitve language.
-    2. For each requirement, describe in detail how MicroHealth will innovate to address it.
-    3. Explain the industry best practices that will be applied and the workflow to accomplish the steps in the best practice to address the requirement.
-    4. Provide measurable outcomes for the customer.
-    5. ALWAYS nLimit the use of bullet points and write predominantly in paragraph format.
-    6. Ensure a logical flow of steps taken by MicroHealth for each requirement.
-    7. Where applicable, describe the labor category or labor categories that perform the task as part of the process
-    8. Analyze the given requirement for MicroHealth and describe the proposed solution, incorporating relevant industry best practices. 
-    9. Focus on Implementation: Ensure responses primarily detail the "how" of the approach, emphasizing steps, industry standards, best practices, and processes informed by authoritative sources such as GAO reports.
-    10. Value Proposition: Align with the customer's mission and objectives.
-    11. Persuasive Writing: Use strong, active language.
-    12. Implementation Focus: Detail specific implementation processes.
-    13. Quantifiable Impact: Use metrics and success stories to demonstrate value.
-    Generate a comprehensive response that showcases MicroHealth's expertise and approach.
-    """
-    response = model.generate_content(prompt)
-    return response.text
-
-def evaluate_compliance(document: str, requirements: str) -> str:
-    prompt = f"""
-    Evaluate the following document against the requirements from sections L&M of the PWS:
-    Document:
-    {document}
-    Requirements:
-    {requirements}
-    Provide a compliance report by section number, highlighting:
-    1. Areas that need improvement
-    2. Suggestions on how MicroHealth can better respond to the requirements
-    3. Best industry practices that should be applied
-    4. Measurable outcomes that should be included
-    5. Organize by document section headers and numbers
-    Format the report clearly by section number.
-    """
-    response = model.generate_content(prompt)
-    return response.text
-
-def generate_red_document(document: str, compliance_report: str, instructions: str) -> str:
-    prompt = f"""
-    Based on the following document and compliance report:
-    Original Document:
-    {document}
-    Compliance Report:
-    {compliance_report}
-    Additional instructions: {instructions}
-    Generate a revised "Red Team" document that addresses all issues found in the compliance report. 
-    Follow these guidelines:
-    1. Use Wikipedia style writing with active voice.  Be firm with the approach, no soft words like could be, may be, should, might.  Use definitive language.
-    2. For each requirement, describe in detail how MicroHealth will innovate to address it.
-    3. Explain the industry best practices that will be applied and the workflow to accomplish the steps in the best practice to address the requirement.
-    4. Provide measurable outcomes for the customer.
-    5. ALWAYS Limit the use of bullet points and write predominantly in paragraph format.
-    6. Ensure a logical flow of steps taken by MicroHealth for each requirement.
-    7. Where applicable, describe the labor category or labor categories that perform the task as part of the process
-    8. Analyze the given requirement for MicroHealth and describe the proposed solution, incorporating relevant industry best practices. 
-    9. Focus on Implementation: Ensure responses primarily detail the "how" of the approach, emphasizing steps, industry standards, best practices, and processes informed by authoritative sources such as GAO reports.
-    10. Value Proposition: Align with the customer's mission and objectives.
-    11. Persuasive Writing: Use strong, active language.
-    12. Implementation Focus: Detail specific implementation processes.
-    13. Quantifiable Impact: Use metrics and success stories to demonstrate value.
-    Generate a comprehensive response that showcases MicroHealth's expertise and approach.
-     
-    """
-    response = model.generate_content(prompt)
-    return response.text
-
-def generate_loe(document: str, is_file: bool = False) -> Tuple[str, pd.DataFrame]:
-    if is_file:
-        # Process the uploaded document
-        document_text = process_document(document, document.split(',')[0])
-    else:
-        document_text = document
-
-    prompt = f"""
-    Analyze the following document and provide a Level of Effort (LOE) breakdown:
-    Document:
-    {document_text}
-    For each section header in the document:
-    1. Identify the tasks to be completed
-    2. Determine the appropriate labor categories for each task
-    3. Estimate the number of hours required for each labor category to complete the task
-    Provide a detailed breakdown and then summarize the information in a tabular format with the following columns:
-    - Task Summary
-    - Labor Categories
-    - Hours per Labor Category
-    - Total Hours
-    Present the detailed breakdown first, followed by the summary table.
-    Ensure the table is properly formatted with | as column separators and a header row.
-    """
-    response = model.generate_content(prompt)
-    response_text = response.text
-    
-    # Extract the table from the response
-    table_start = response_text.find("| Task Summary |")
-    table_end = response_text.find("\n\n", table_start)
-    table_text = response_text[table_start:table_end]
-    
-    # Convert the table to a pandas DataFrame
-    try:
-        if not table_text.strip():
-            raise pd.errors.EmptyDataError("No table found in the response")
-        df = pd.read_csv(StringIO(table_text), sep='|', skipinitialspace=True).dropna(axis=1, how='all')
-        df.columns = df.columns.str.strip()
-    except pd.errors.EmptyDataError:
-        # If no table is found or it's empty, create a default DataFrame
-        df = pd.DataFrame(columns=['Task Summary', 'Labor Categories', 'Hours per Labor Category', 'Total Hours'])
-        response_text += "\n\nNote: No detailed LOE table could be generated from the AI response."
-    
-    return response_text, df
-
-# Layout
-app.layout = dbc.Container([
-    html.H1("MicroHealth PWS Analysis and Response Generator", className="my-4"),
-    dbc.Tabs([
-        dbc.Tab(label="Shred", tab_id="shred", children=[
-            dbc.Textarea(
-                id='shred-instructions',
-                placeholder="Enter any additional instructions for shredding the document...",
-                style={'height': '100px', 'marginBottom': '10px'}
-            ),
-            dcc.Upload(
-                id='upload-document',
-                children=html.Div(['Drag and Drop or ', html.A('Select Files')]),
-                style={
-                    'width': '100%',
-                    'height': '60px',
-                    'lineHeight': '60px',
-                    'borderWidth': '1px',
-                    'borderStyle': 'dashed',
-                    'borderRadius': '5px',
-                    'textAlign': 'center',
-                    'margin': '10px'
-                },
-                multiple=False
-            ),
-            dbc.Spinner(html.Div(id='shred-output')),
-            dbc.Button("Download Outline", id="download-shred", className="mt-3"),
-            dcc.Download(id="download-shred-doc")
-        ]),
-        dbc.Tab(label="Pink", tab_id="pink", children=[
-            dbc.Textarea(
-                id='pink-instructions',
-                placeholder="Enter any additional instructions for generating the Pink Team document...",
-                style={'height': '100px', 'marginBottom': '10px'}
-            ),
-            dbc.Button("Generate Pink Team Document", id="generate-pink", className="mt-3"),
-            dbc.Spinner(html.Div(id='pink-output')),
-            dbc.Button("Download Pink Team Document", id="download-pink", className="mt-3"),
-            dcc.Download(id="download-pink-doc")
-        ]),
-        dbc.Tab(label="P.Review", tab_id="p-review", children=[
-            dcc.Upload(
-                id='upload-p-review',
-                children=html.Div(['Drag and Drop or ', html.A('Select Files')]),
-                style={
-                    'width': '100%',
-                    'height': '60px',
-                    'lineHeight': '60px',
-                    'borderWidth': '1px',
-                    'borderStyle': 'dashed',
-                    'borderRadius': '5px',
-                    'textAlign': 'center',
-                    'margin': '10px'
-                },
-                multiple=False
-            ),
-            dbc.Button("Evaluate Compliance", id="evaluate-p-review", className="mt-3"),
-            dbc.Spinner(html.Div(id='p-review-output')),
-            dbc.Button("Download P.Review Report", id="download-p-review", className="mt-3"),
-            dcc.Download(id="download-p-review-doc")
-        ]),
-        dbc.Tab(label="Red", tab_id="red", children=[
-            dbc.Textarea(
-                id='red-instructions',
-                placeholder="Enter any additional instructions for generating the Red Team document...",
-                style={'height': '100px', 'marginBottom': '10px'}
-            ),
-            dcc.Upload(
-                id='upload-red',
-                children=html.Div(['Drag and Drop or ', html.A('Select Files')]),
-                style={
-                    'width': '100%',
-                    'height': '60px',
-                    'lineHeight': '60px',
-                    'borderWidth': '1px',
-                    'borderStyle': 'dashed',
-                    'borderRadius': '5px',
-                    'textAlign': 'center',
-                    'margin': '10px'
-                },
-                multiple=False
-            ),
-            dbc.Button("Generate Red Team Document", id="generate-red", className="mt-3"),
-            dbc.Spinner(html.Div(id='red-output')),
-            dbc.Button("Download Red Team Document", id="download-red", className="mt-3"),
-            dcc.Download(id="download-red-doc")
-        ]),
-        dbc.Tab(label="R.Review", tab_id="r-review", children=[
-            dcc.Upload(
-                id='upload-r-review',
-                children=html.Div(['Drag and Drop or ', html.A('Select Files')]),
-                style={
-                    'width': '100%',
-                    'height': '60px',
-                    'lineHeight': '60px',
-                    'borderWidth': '1px',
-                    'borderStyle': 'dashed',
-                    'borderRadius': '5px',
-                    'textAlign': 'center',
-                    'margin': '10px'
-                },
-                multiple=False
-            ),
-            dbc.Button("Evaluate Compliance", id="evaluate-r-review", className="mt-3"),
-            dbc.Spinner(html.Div(id='r-review-output')),
-            dbc.Button("Download R.Review Report", id="download-r-review", className="mt-3"),
-            dcc.Download(id="download-r-review-doc")
-        ]),
-        dbc.Tab(label="G.Review", tab_id="g-review", children=[
-            dcc.Upload(
-                id='upload-g-review',
-                children=html.Div(['Drag and Drop or ', html.A('Select Files')]),
-                style={
-                    'width': '100%',
-                    'height': '60px',
-                    'lineHeight': '60px',
-                    'borderWidth': '1px',
-                    'borderStyle': 'dashed',
-                    'borderRadius': '5px',
-                    'textAlign': 'center',
-                    'margin': '10px'
-                },
-                multiple=False
-            ),
-            dbc.Button("Evaluate Compliance", id="evaluate-g-review", className="mt-3"),
-            dbc.Spinner(html.Div(id='g-review-output')),
-            dbc.Button("Download G.Review Report", id="download-g-review", className="mt-3"),
-            dcc.Download(id="download-g-review-doc")
-        ]),
-        dbc.Tab(label="LOE", tab_id="loe", children=[
-            dcc.Upload(
-                id='upload-loe',
-                children=html.Div(['Drag and Drop or ', html.A('Select Files')]),
-                style={
-                    'width': '100%',
-                    'height': '60px',
-                    'lineHeight': '60px',
-                    'borderWidth': '1px',
-                    'borderStyle': 'dashed',
-                    'borderRadius': '5px',
-                    'textAlign': 'center',
-                    'margin': '10px'
-                },
-                multiple=False
-            ),
-            dbc.Button("Generate LOE", id="generate-loe", className="mt-3"),
-            dbc.Spinner(html.Div(id='loe-output')),
-            dbc.Button("Download LOE Report", id="download-loe", className="mt-3"),
-            dcc.Download(id="download-loe-doc")
-        ]),
-    ], id="tabs", active_tab="shred"),
-])
-
-@app.callback(
-    Output('shred-output', 'children'),
-    Input('upload-document', 'contents'),
-    State('upload-document', 'filename'),
-    State('shred-instructions', 'value')
-)
-def update_shred_output(contents, filename, instructions):
-    if contents is None:
-        return "Upload a document to begin."
-    
-    text = process_document(contents, filename)
-    outline = generate_outline(text, instructions or "")
-    return dcc.Markdown(outline)
-
-@app.callback(
-    Output('pink-output', 'children'),
-    Input('generate-pink', 'n_clicks'),
-    State('shred-output', 'children'),
-    State('pink-instructions', 'value')
-)
-def update_pink_output(n_clicks, shred_output, instructions):
-    if n_clicks is None or shred_output is None:
-        return "Generate an outline in the Shred tab first."
-    
-    pink_doc = generate_pink_team_document(shred_output, instructions or "")
-    return dcc.Markdown(pink_doc)
-
-@app.callback(
-    Output('p-review-output', 'children'),
-    Input('evaluate-p-review', 'n_clicks'),
-    State('upload-p-review', 'contents'),
-    State('upload-p-review', 'filename'),
-    State('pink-output', 'children'),
-    State('shred-output', 'children')
-)
-def update_p_review_output(n_clicks, contents, filename, pink_doc, requirements):
-    if n_clicks is None:
-        return "Click 'Evaluate Compliance' to begin."
-    
-    if contents:
-        document = process_document(contents, filename)
-    elif pink_doc:
-        document = pink_doc
-    else:
-        return "Please upload a document or generate a Pink Team document first."
-    
-    compliance_report = evaluate_compliance(document, requirements)
-    return dcc.Markdown(compliance_report)
-
-@app.callback(
-    Output('g-review-output', 'children'),
-    Input('evaluate-g-review', 'n_clicks'),
-    State('upload-g-review', 'contents'),
-    State('upload-g-review', 'filename'),
-    State('shred-output', 'children')
-)
-def update_g_review_output(n_clicks, contents, filename, requirements):
-    if n_clicks is None:
-        return "Click 'Evaluate Compliance' to begin."
-    
-    if contents is None:
-        return "Please upload a document first."
-    
-    document = process_document(contents, filename)
-    compliance_report = evaluate_compliance(document, requirements)
-    return dcc.Markdown(compliance_report)
-
-@app.callback(
-    Output('loe-output', 'children'),
-    Input('generate-loe', 'n_clicks'),
-    State('upload-loe', 'contents'),
-    State('shred-output', 'children')
-)
-def update_loe_output(n_clicks, upload_contents, shred_output):
-    if n_clicks is None:
-        return "Click 'Generate LOE' to begin."
-    
-    try:
-        if upload_contents:
-            loe_text, loe_df = generate_loe(upload_contents, is_file=True)
-        elif shred_output:
-            loe_text, loe_df = generate_loe(shred_output)
-        else:
-            return "Please upload a document or complete the Shred tab first."
-        
-        return [
-            dcc.Markdown(loe_text),
-            dash_table.DataTable(
-                data=loe_df.to_dict('records'),
-                columns=[{'name': i, 'id': i} for i in loe_df.columns],
-                style_table={'overflowX': 'auto'},
-                style_cell={'textAlign': 'left', 'padding': '5px'},
-                style_header={'backgroundColor': 'rgb(230, 230, 230)', 'fontWeight': 'bold'}
-            )
-        ]
-    except Exception as e:
-        return f"An error occurred: {str(e)}"
-
-@app.callback(
-    Output('red-output', 'children'),
-    Input('generate-red', 'n_clicks'),
-    State('upload-red', 'contents'),
-    State('upload-red', 'filename'),
-    State('p-review-output', 'children'),
-    State('red-instructions', 'value')
-)
-def update_red_output(n_clicks, contents, filename, p_review_output, instructions):
-    if n_clicks is None:
-        return "Click 'Generate Red Team Document' to begin."
-    
-    if contents:
-        document = process_document(contents, filename)
-    elif p_review_output:
-        document = p_review_output
+    if filename.lower().endswith('.docx'):
+        doc = Document(BytesIO(decoded))
+        return "\n".join([p.text for p in doc.paragraphs])
+    elif filename.lower().endswith('.pdf'):
+        pdf = PdfReader(BytesIO(decoded))
+        return "".join(page.extract_text() or "" for page in pdf.pages)
     else:
-        return "Please upload a document or complete the P.Review first."
-    
-    red_doc = generate_red_document(document, p_review_output, instructions or "")
-    return dcc.Markdown(red_doc)  # Wrap the output in dcc.Markdown)
-
-@app.callback(
-    Output('r-review-output', 'children'),
-    Input('evaluate-r-review', 'n_clicks'),
-    State('upload-r-review', 'contents'),
-    State('upload-r-review', 'filename'),
-    State('red-output', 'children'),
-    State('shred-output', 'children')
-)
-def update_r_review_output(n_clicks, contents, filename, red_doc, requirements):
-    if n_clicks is None:
-        return "Click 'Evaluate Compliance' to begin."
-    
-    if contents:
-        document = process_document(contents, filename)
-    elif red_doc:
-        document = red_doc
-    else:
-        return "Please upload a document or generate a Red Team document first."
-    
-    compliance_report = evaluate_compliance(document, requirements)
-    return dcc.Markdown(compliance_report)
+        return f"Unsupported file format: {filename}"
+
+def call_claude(prompt, max_tokens=2048):
+    res = anthropic_client.messages.create(
+        model=CLAUDE3_SONNET_MODEL,
+        max_tokens=max_tokens,
+        temperature=0.1,
+        system="You are a world class proposal consultant and proposal manager.",
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return res.content[0].text if hasattr(res, "content") else str(res)
+
+def spreadsheet_to_df(text):
+    lines = [l.strip() for l in text.splitlines() if '|' in l]
+    if not lines: return pd.DataFrame()
+    header = lines[0].strip('|').split('|')
+    data = [l.strip('|').split('|') for l in lines[1:]]
+    return pd.DataFrame(data, columns=[h.strip() for h in header])
+
+def generate_content(document, doc_type):
+    prompt = f"{document_types[doc_type]}\n\nDocument:\n{document}\n\nOutput only one spreadsheet table, use | as column separator."
+    response = call_claude(prompt, max_tokens=4096)
+    df = spreadsheet_to_df(response)
+    return response, df
 
 def parse_markdown(doc, content):
-    # Split content into paragraphs
-    paragraphs = content.split('\n\n')
-    
-    for para in paragraphs:
-        # Check for headers
-        header_match = re.match(r'^(#{1,6})\s+(.+)$', para)
-        if header_match:
-            level = len(header_match.group(1))
-            text = header_match.group(2)
-            doc.add_heading(text, level=level)
-        else:
-            p = doc.add_paragraph()
-            # Split paragraph into runs
-            runs = re.split(r'(\*\*|\*|__|\~\~)', para)
-            is_bold = is_italic = is_underline = is_strikethrough = False
-            for run in runs:
-                if run == '**' or run == '__':
-                    is_bold = not is_bold
-                elif run == '*':
-                    is_italic = not is_italic
-                elif run == '~~':
-                    is_strikethrough = not is_strikethrough
-                else:
-                    r = p.add_run(run)
-                    r.bold = is_bold
-                    r.italic = is_italic
-                    r.underline = is_underline
-                    r.font.strike = is_strikethrough
+    for para in content.split('\n\n'):
+        doc.add_paragraph(para)
 
 def create_docx(content):
     doc = Document()
-    
-    # Add styles
-    styles = doc.styles
-    style_names = [style.name for style in styles]
-    if 'Code' not in style_names:
-        code_style = styles.add_style('Code', WD_STYLE_TYPE.PARAGRAPH)
-        code_font = code_style.font
-        code_font.name = 'Courier New'
-        code_font.size = Pt(10)
-    
     parse_markdown(doc, content)
     return doc
 
-@app.callback(
-    Output("download-shred-doc", "data"),
-    Input("download-shred", "n_clicks"),
-    State('shred-output', 'children'),
-    prevent_initial_call=True,
-)
-def download_shred(n_clicks, shred_output):
-    if shred_output is None:
-        return dash.no_update
-    doc = create_docx(shred_output)
-    buffer = BytesIO()
-    doc.save(buffer)
-    return dcc.send_bytes(buffer.getvalue(), "shred_outline.docx")
-
-@app.callback(
-    Output("download-pink-doc", "data"),
-    Input("download-pink", "n_clicks"),
-    State('pink-output', 'children'),
-    prevent_initial_call=True,
-)
-def download_pink(n_clicks, pink_output):
-    if pink_output is None:
-        return dash.no_update
-    doc = create_docx(pink_output)
-    buffer = BytesIO()
-    doc.save(buffer)
-    return dcc.send_bytes(buffer.getvalue(), "pink_team_document.docx")
-
-@app.callback(
-    Output("download-p-review-doc", "data"),
-    Input("download-p-review", "n_clicks"),
-    State('p-review-output', 'children'),
-    prevent_initial_call=True,
-)
-def download_p_review(n_clicks, p_review_output):
-    if p_review_output is None:
-        return dash.no_update
-    doc = create_docx(p_review_output)
-    buffer = BytesIO()
-    doc.save(buffer)
-    return dcc.send_bytes(buffer.getvalue(), "p_review_report.docx")
+app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP], suppress_callback_exceptions=True)
+app.title = "MicroHealth PWS Analyzer"
+
+nav_items = [
+    dbc.NavLink("Shred", href="#", id="nav-shred"),
+    dbc.NavLink("Pink", href="#", id="nav-pink"),
+    dbc.NavLink("Pink Review", href="#", id="nav-pink-review"),
+    dbc.NavLink("Red", href="#", id="nav-red"),
+    dbc.NavLink("Red Review", href="#", id="nav-red-review"),
+    dbc.NavLink("Gold", href="#", id="nav-gold"),
+    dbc.NavLink("Gold Review", href="#", id="nav-gold-review"),
+    dbc.NavLink("Virtual Board", href="#", id="nav-virtual-board"),
+    dbc.NavLink("LOE", href="#", id="nav-loe"),
+]
+
+def make_upload(btn_id):
+    return dcc.Upload(
+        id=f'{btn_id}-upload',
+        children=html.Div(['Drag and Drop or ', html.A('Select Files')]),
+        style={'width': '100%', 'height': '60px', 'lineHeight': '60px', 'borderWidth': '1px', 'borderStyle': 'dashed', 'borderRadius': '5px', 'textAlign': 'center', 'margin': '10px'},
+        multiple=False
+    )
+
+def make_textarea(btn_id, placeholder):
+    return dbc.Textarea(
+        id=f'{btn_id}-instructions',
+        placeholder=placeholder,
+        style={'height': '80px', 'marginBottom': '10px', 'width': '100%', 'whiteSpace': 'pre-wrap', 'overflowWrap': 'break-word'}
+    )
+
+def make_tab(tab_id, label):
+    return dbc.Card(
+        dbc.CardBody([
+            make_textarea(tab_id, f"Instructions for {label} (optional)"),
+            make_upload(tab_id),
+            dbc.Button(f"Generate {label}", id=f'{tab_id}-btn', className="mt-2 btn-primary", n_clicks=0),
+            dcc.Loading(html.Div(id=f'{tab_id}-output'), type="default", parent_style={'justifyContent': 'center'}),
+            dbc.Button(f"Download {label} Report", id=f"{tab_id}-download-btn", className="mt-2 btn-secondary", n_clicks=0),
+            dcc.Download(id=f"{tab_id}-download")
+        ]), className="mb-4"
+    )
+
+main_tabs = [
+    {"id": "shred", "label": "Shred"},
+    {"id": "pink", "label": "Pink"},
+    {"id": "pink-review", "label": "Pink Review"},
+    {"id": "red", "label": "Red"},
+    {"id": "red-review", "label": "Red Review"},
+    {"id": "gold", "label": "Gold"},
+    {"id": "gold-review", "label": "Gold Review"},
+    {"id": "virtual-board", "label": "Virtual Board"},
+    {"id": "loe", "label": "LOE"},
+]
 
-@app.callback(
-    Output("download-red-doc", "data"),
-    Input("download-red", "n_clicks"),
-    State('red-output', 'children'),
-    prevent_initial_call=True,
-)
-def download_red(n_clicks, red_output):
-    if red_output is None:
-        return dash.no_update
-    
-    # Extract the content from the Markdown component
-    if isinstance(red_output, dict) and 'props' in red_output and 'children' in red_output['props']:
-        content = red_output['props']['children']
-    else:
-        content = str(red_output)
-    
-    doc = create_docx(content)
-    buffer = BytesIO()
-    doc.save(buffer)
-    return dcc.send_bytes(buffer.getvalue(), "red_team_document.docx")
-
-@app.callback(
-    Output("download-r-review-doc", "data"),
-    Input("download-r-review", "n_clicks"),
-    State('r-review-output', 'children'),
-    prevent_initial_call=True,
-)
-def download_r_review(n_clicks, r_review_output):
-    if r_review_output is None:
-        return dash.no_update
-    doc = create_docx(r_review_output)
-    buffer = BytesIO()
-    doc.save(buffer)
-    return dcc.send_bytes(buffer.getvalue(), "r_review_report.docx")
-
-@app.callback(
-    Output("download-g-review-doc", "data"),
-    Input("download-g-review", "n_clicks"),
-    State('g-review-output', 'children'),
-    prevent_initial_call=True,
-)
-def download_g_review(n_clicks, g_review_output):
-    if g_review_output is None:
-        return dash.no_update
-    doc = create_docx(g_review_output)
-    buffer = BytesIO()
-    doc.save(buffer)
-    return dcc.send_bytes(buffer.getvalue(), "g_review_report.docx")
+app.layout = dbc.Container([
+    html.H1("MicroHealth PWS Analysis and Response Generator", className="my-3"),
+    dbc.Row([
+        dbc.Col(
+            dbc.Card(
+                dbc.CardBody([
+                    html.Div(nav_items, className="nav flex-column"),
+                ])
+            ), width=3, style={'minWidth': '220px'}
+        ),
+        dbc.Col(
+            html.Div([
+                dcc.Tabs(
+                    id="main-tabs",
+                    value="shred",
+                    children=[dcc.Tab(label=tab["label"], value=tab["id"]) for tab in main_tabs],
+                    className="mb-3"
+                ),
+                html.Div(id="main-content")
+            ]),
+            width=9
+        )
+    ])
+], fluid=True)
+
+tab_cards = {tab["id"]: make_tab(tab["id"], tab["label"]) for tab in main_tabs}
 
 @app.callback(
-    Output("download-loe-doc", "data"),
-    Input("download-loe", "n_clicks"),
-    State('loe-output', 'children'),
-    prevent_initial_call=True,
+    Output('main-content', 'children'),
+    Input('main-tabs', 'value')
 )
-def download_loe(n_clicks, loe_output):
-    if loe_output is None or isinstance(loe_output, str):
-        return dash.no_update
-    loe_text = loe_output[0]['props']['children']
-    doc = create_docx(loe_text)
-    buffer = BytesIO()
-    doc.save(buffer)
-    return dcc.send_bytes(buffer.getvalue(), "loe_report.docx")
-
-from dash import callback_context
+def render_tab(tab):
+    return tab_cards[tab]
 
 @app.callback(
-    Output('loe-output', 'children', allow_duplicate=True),
-    Input('generate-loe', 'n_clicks'),
-    Input('upload-loe', 'contents'),
-    State('upload-loe', 'filename'),
-    State('shred-output', 'children'),
-    prevent_initial_call=True
+    [Output(f'{tab_id}-output', 'children') for tab_id in tab_cards] +
+    [Output(f"{tab_id}-download", "data") for tab_id in tab_cards],
+    [Input(f'{tab_id}-btn', 'n_clicks') for tab_id in tab_cards] +
+    [Input(f"{tab_id}-download-btn", "n_clicks") for tab_id in tab_cards],
+    [State(f'{tab_id}-upload', 'contents') for tab_id in tab_cards] +
+    [State(f'{tab_id}-upload', 'filename') for tab_id in tab_cards] +
+    [State(f'{tab_id}-instructions', 'value') for tab_id in tab_cards] +
+    [State(f'{tab_id}-output', 'children') for tab_id in tab_cards]
 )
-def update_loe_output(n_clicks, upload_contents, upload_filename, shred_output):
+def handle_all_tabs(*args):
+    n = len(tab_cards)
+    outputs = [None] * (n * 2)
     ctx = callback_context
-    triggered_id = ctx.triggered[0]['prop_id'].split('.')[0]
-
-    if not ctx.triggered:
-        return dash.no_update
-
-    try:
-        if triggered_id in ['generate-loe', 'upload-loe']:
-            if upload_contents:
-                document = process_document(upload_contents, upload_filename)
-                if document.startswith("Unsupported file format") or document.startswith("Error processing document"):
-                    return document
-                loe_text, loe_df = generate_loe(document)
-            elif shred_output:
-                loe_text, loe_df = generate_loe(shred_output)
+    if not ctx.triggered: return outputs
+    trig = ctx.triggered[0]['prop_id']
+    for idx, tab_id in enumerate(tab_cards):
+        gen_btn = f"{tab_id}-btn.n_clicks"
+        dl_btn = f"{tab_id}-download-btn.n_clicks"
+        out_idx = idx
+        dl_idx = idx + n
+        upload_idx = idx
+        filename_idx = idx + n
+        instr_idx = idx + 2 * n
+        prev_output_idx = idx + 3 * n
+
+        if trig == gen_btn:
+            upload = args[upload_idx]
+            filename = args[filename_idx]
+            instr = args[instr_idx] or ""
+            doc_type = tab_id.replace('-', ' ').title().replace(' ', '')
+            doc_type = next((k for k in document_types if k.lower().replace(' ', '') == tab_id.replace('-', '')), tab_id.title())
+            if upload and filename:
+                doc = process_document(upload, filename)
+            else:
+                doc = ""
+            if doc or tab_id == "virtual-board":
+                content, df = generate_content(doc, doc_type)
+                if not df.empty:
+                    outputs[out_idx] = dash_table.DataTable(
+                        data=df.to_dict('records'),
+                        columns=[{'name': i, 'id': i} for i in df.columns],
+                        style_table={'overflowX': 'auto'},
+                        style_cell={'textAlign': 'left', 'padding': '5px'},
+                        style_header={'fontWeight': 'bold'}
+                    )
+                else:
+                    outputs[out_idx] = dcc.Markdown(content)
+            else:
+                outputs[out_idx] = "Please upload a document to begin."
+        elif trig == dl_btn:
+            prev_output = args[prev_output_idx]
+            if prev_output and hasattr(prev_output, 'props') and 'data' in prev_output.props:
+                df = pd.DataFrame(prev_output.props['data'])
+                buffer = BytesIO()
+                df.to_csv(buffer, index=False)
+                outputs[dl_idx] = dcc.send_bytes(buffer.getvalue(), f"{tab_id}_report.csv")
+            elif prev_output:
+                buffer = BytesIO(prev_output.encode("utf-8") if isinstance(prev_output, str) else b"")
+                outputs[dl_idx] = dcc.send_bytes(buffer.getvalue(), f"{tab_id}_report.txt")
             else:
-                return "Please upload a document or complete the Shred tab first."
-        
-        return [
-            dcc.Markdown(loe_text),
-            dash_table.DataTable(
-                data=loe_df.to_dict('records'),
-                columns=[{'name': i, 'id': i} for i in loe_df.columns],
-                style_table={'overflowX': 'auto'},
-                style_cell={'textAlign': 'left', 'padding': '5px'},
-                style_header={'backgroundColor': 'rgb(230, 230, 230)', 'fontWeight': 'bold'}
-            )
-        ]
-    except Exception as e:
-        return f"An error occurred: {str(e)}"
+                outputs[dl_idx] = None
+    return outputs
 
 if __name__ == '__main__':
     print("Starting the Dash application...")
-    app.run(debug=True, host='0.0.0.0', port=7860)
+    threading.Thread(target=lambda: app.run(debug=True, host='0.0.0.0', port=7860, threaded=True)).start()
     print("Dash application has finished running.")