Update app.py via AI Editor

app.py

@@ -25,15 +25,6 @@ app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP], suppress_
 openai.api_key = os.environ.get("OPENAI_API_KEY", "")
 
 uploaded_files = {}
-current_document = None
-document_type = None
-shredded_document = None
-pink_review_document = None
-pink_document = None
-red_review_document = None
-red_document = None
-gold_review_document = None
-gold_document = None
 uploaded_doc_contents = {}
 
 spreadsheet_types = ["Shred", "Pink Review", "Red Review", "Gold Review", "Virtual Board", "LOE"]
@@ -51,7 +42,6 @@ document_types = {
     "LOE": "Ignore all other instructions and generate and generate a Level of Effort (LOE) breakdown and produce only spreadsheet"
 }
 
-# Document dependency rules: mapping doc type to allowed sources for generation and review
 doc_dependencies = {
     "Pink": {"source": ["shred"], "require": True},
     "Pink Review": {"source": ["pink", "shred"], "require": True},
@@ -63,7 +53,185 @@ doc_dependencies = {
     "Virtual Board": {"source": ["shred"], "require": True},
 }
 
-def get_right_col_content(selected_type):
+def extract_markdown_tables(md_text):
+    tables = []
+    lines = md_text.split('\n')
+    in_table = False
+    table_lines = []
+    for line in lines:
+        if re.match(r'^\s*\|.*\|\s*$', line):
+            in_table = True
+            table_lines.append(line)
+        elif in_table and (re.match(r'^\s*\|.*\|\s*$', line) or re.match(r'^\s*$', line)):
+            table_lines.append(line)
+        else:
+            if in_table and table_lines:
+                tables.append('\n'.join(table_lines))
+                table_lines = []
+            in_table = False
+    if in_table and table_lines:
+        tables.append('\n'.join(table_lines))
+    return tables
+
+def markdown_table_to_df(md_table):
+    lines = [line.strip() for line in md_table.split('\n') if line.strip()]
+    if len(lines) < 2:
+        return None
+    header = [h.strip() for h in lines[0].strip('|').split('|')]
+    sep_idx = 1
+    while sep_idx < len(lines) and not re.match(r'^\|\s*:?-+:?\s*(\|\s*:?-+:?\s*)+\|?$', lines[sep_idx]):
+        sep_idx += 1
+    data_lines = lines[sep_idx+1:] if sep_idx+1 < len(lines) else []
+    rows = []
+    for row in data_lines:
+        if not row.strip() or not row.strip().startswith('|'):
+            continue
+        cells = [c.strip() for c in row.strip('|').split('|')]
+        if len(cells) < len(header):
+            cells += [''] * (len(header) - len(cells))
+        elif len(cells) > len(header):
+            cells = cells[:len(header)]
+        rows.append(cells)
+    df = pd.DataFrame(rows, columns=header)
+    return df
+
+def markdown_table_preview(md_text):
+    tables = extract_markdown_tables(md_text)
+    if not tables:
+        return html.Div("No table found.")
+    table_divs = []
+    for i, table in enumerate(tables):
+        df = markdown_table_to_df(table)
+        if df is not None and not df.empty:
+            table_divs.append(
+                html.Div([
+                    DataTable(
+                        columns=[{"name": str(col), "id": str(col)} for col in df.columns],
+                        data=df.to_dict('records'),
+                        style_table={'overflowX': 'auto'},
+                        style_cell={'whiteSpace': 'normal', 'height': 'auto', 'textAlign': 'left', 'fontFamily': 'monospace', 'fontSize': '14px', 'maxWidth': '400px', 'minWidth': '80px', 'wordBreak': 'break-word'},
+                        style_header={'fontWeight': 'bold'},
+                        page_size=100,
+                        id={'type': 'datatable-preview', 'index': i}
+                    )
+                ], className="mb-4")
+            )
+    return html.Div(table_divs)
+
+def markdown_narrative_preview(md_text):
+    return html.Div(dcc.Markdown(md_text, dangerously_allow_html=True, style={'whiteSpace': 'pre-wrap', 'fontFamily': 'sans-serif'}))
+
+def markdown_tables_to_xlsx(md_text):
+    tables = extract_markdown_tables(md_text)
+    output = BytesIO()
+    with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+        for i, table in enumerate(tables):
+            df = markdown_table_to_df(table)
+            if df is not None:
+                sheet_name = f"Table{i+1}"
+                df.to_excel(writer, sheet_name=sheet_name, index=False)
+    output.seek(0)
+    return output
+
+def strip_markdown(text):
+    text = re.sub(r'(\*\*|__)(.*?)\1', r'\2', text)
+    text = re.sub(r'(\*|_)(.*?)\1', r'\2', text)
+    text = re.sub(r'`{1,3}[^`]*`{1,3}', '', text)
+    text = re.sub(r'^#+ ', '', text, flags=re.MULTILINE)
+    text = re.sub(r'^> ', '', text, flags=re.MULTILINE)
+    text = re.sub(r'!\[.*?\]\(.*?\)', '', text)
+    text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
+    text = re.sub(r'^\s*[-*+] ', '', text, flags=re.MULTILINE)
+    text = re.sub(r'^\s*\d+\.\s+', '', text, flags=re.MULTILINE)
+    text = text.replace('---', '')
+    text = text.replace('___', '')
+    text = text.replace('***', '')
+    return text.strip()
+
+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:
+                page_text = page.extract_text()
+                if page_text:
+                    text += page_text
+            return text
+        else:
+            return f"Unsupported file format: {filename}. Please upload a PDF or DOCX file."
+    except Exception as e:
+        logging.error(f"Error processing document: {str(e)}")
+        return f"Error processing document: {str(e)}"
+
+def file_list_component():
+    return html.Div(
+        id='file-list-container',
+        children=[
+            html.Div(id='file-list')
+        ]
+    )
+
+def get_left_col_content():
+    chat_card = dbc.Card(
+        dbc.CardBody([
+            html.H5("Maiko Chat", className="mb-2"),
+            dcc.Loading(
+                id="chat-loading",
+                type="dot",
+                children=[
+                    dcc.Textarea(
+                        id="chat-input",
+                        placeholder="Chat with AI to update document...",
+                        className="mb-2",
+                        style={
+                            'whiteSpace':'pre-wrap',
+                            'width': '100%',
+                            'minHeight': '100px',
+                            'maxHeight': '300px',
+                            'resize': 'vertical',
+                            'overflowY': 'auto'
+                        },
+                        rows=5,
+                        wrap='soft'
+                    ),
+                    dcc.Store(id="chat-input-rows", data=5),
+                    dbc.Row([
+                        dbc.Col(
+                            dbc.Button("Send", id="btn-send-chat", color="primary", className="mb-3 w-100"),
+                            width=6
+                        ),
+                        dbc.Col(
+                            dbc.Button("Clear Chat", id="btn-clear-chat", color="secondary", className="mb-3 w-100"),
+                            width=6
+                        ),
+                    ], className="g-1 mb-2"),
+                    html.Div(id="chat-output")
+                ]
+            )
+        ]),
+        className="mt-4"
+    )
+    return [
+        html.H4("Proposal Writer", className="mt-3 mb-2", style={'marginBottom': '12px'}),
+        html.Div([
+            html.Div(className="blinking-dot", style={'margin':'0 auto','width':'16px','height':'16px'}),
+        ], style={'textAlign':'center', 'marginBottom':'10px'}),
+        html.Hr(style={'marginTop': '8px', 'marginBottom': '16px'}),
+        html.Div(
+            id='doc-type-buttons'
+        ),
+        chat_card
+    ]
+
+def get_right_col_content(selected_type, 
+                          shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc):
     controls = []
     controls.append(html.Div([
         html.Div(className="blinking-dot", style={'margin':'0 auto','width':'16px','height':'16px'}),
@@ -73,7 +241,6 @@ def get_right_col_content(selected_type):
         type="dot",
         children=[html.Div(id="loading-output")]
     ))
-    # Shred: can always upload
     if selected_type == "Shred":
         controls.append(
             html.Div([
@@ -95,35 +262,43 @@ def get_right_col_content(selected_type):
                     },
                     multiple=True
                 ),
-                file_list_component()
+                file_list_component(),
+                html.Div([
+                    html.Div("Loaded Shred Document:", className="mt-2 mb-1"),
+                    markdown_table_preview(shred_doc) if shred_doc else html.Div("No Shred document loaded.")
+                ], style={'marginBottom': '12px'})
             ])
         )
-    # For all proposal/response/review types, show only allowed upload controls
     elif selected_type in doc_dependencies:
         sources = doc_dependencies[selected_type]["source"]
-        # For each source, show upload and radio if loaded/generated exists
         for src in sources:
             label = ""
+            loaded_preview = None
             store_var = None
             if src == "shred":
                 label = "Shred (Requirements)"
-                store_var = shredded_document
+                store_var = shred_doc
+                loaded_preview = markdown_table_preview(shred_doc) if shred_doc else html.Div("No Shred document loaded.")
             elif src == "pink":
                 label = "Pink Document"
-                store_var = pink_document
+                store_var = pink_doc
+                loaded_preview = markdown_narrative_preview(pink_doc) if pink_doc else html.Div("No Pink document loaded.")
             elif src == "pink_review":
                 label = "Pink Review"
-                store_var = pink_review_document
+                store_var = pink_review_doc
+                loaded_preview = markdown_table_preview(pink_review_doc) if pink_review_doc else html.Div("No Pink Review document loaded.")
             elif src == "red":
                 label = "Red Document"
-                store_var = red_document
+                store_var = red_doc
+                loaded_preview = markdown_narrative_preview(red_doc) if red_doc else html.Div("No Red document loaded.")
             elif src == "red_review":
                 label = "Red Review"
-                store_var = red_review_document
+                store_var = red_review_doc
+                loaded_preview = markdown_table_preview(red_review_doc) if red_review_doc else html.Div("No Red Review document loaded.")
             elif src == "gold":
                 label = "Gold Document"
-                store_var = gold_document
-            # Upload control for this source
+                store_var = gold_doc
+                loaded_preview = markdown_narrative_preview(gold_doc) if gold_doc else html.Div("No Gold document loaded.")
             controls.append(html.Div([
                 html.Label(f"Upload {label}"),
                 dcc.Upload(
@@ -152,6 +327,10 @@ def get_right_col_content(selected_type):
                     inline=True,
                     className="mb-2"
                 ),
+                html.Div([
+                    html.Div("Loaded Document Preview:", className="mt-2 mb-1"),
+                    loaded_preview
+                ], style={'marginBottom': '12px'}) if store_var else None,
             ], id={'type': f'doc-type-controls-{src}', 'index': selected_type}))
     controls.append(
         dbc.Row([
@@ -170,68 +349,17 @@ def get_right_col_content(selected_type):
     controls.append(html.Div(id='document-preview', className="border p-3 mb-3"))
     return dbc.Card(dbc.CardBody(controls))
 
-def get_left_col_content():
-    chat_card = dbc.Card(
-        dbc.CardBody([
-            html.H5("Maiko Chat", className="mb-2"),
-            dcc.Loading(
-                id="chat-loading",
-                type="dot",
-                children=[
-                    dcc.Textarea(
-                        id="chat-input",
-                        placeholder="Chat with AI to update document...",
-                        className="mb-2",
-                        style={
-                            'whiteSpace':'pre-wrap',
-                            'width': '100%',
-                            'minHeight': '100px',
-                            'maxHeight': '300px',
-                            'resize': 'vertical',
-                            'overflowY': 'auto'
-                        },
-                        rows=5,
-                        wrap='soft'
-                    ),
-                    dcc.Store(id="chat-input-rows", data=5),
-                    dbc.Row([
-                        dbc.Col(
-                            dbc.Button("Send", id="btn-send-chat", color="primary", className="mb-3 w-100"),
-                            width=6
-                        ),
-                        dbc.Col(
-                            dbc.Button("Clear Chat", id="btn-clear-chat", color="secondary", className="mb-3 w-100"),
-                            width=6
-                        ),
-                    ], className="g-1 mb-2"),
-                    html.Div(id="chat-output")
-                ]
-            )
-        ]),
-        className="mt-4"
-    )
-    return [
-        html.H4("Proposal Writer", className="mt-3 mb-4"),
-        html.Div([
-            html.Div(className="blinking-dot", style={'margin':'0 auto','width':'16px','height':'16px'}),
-        ], style={'textAlign':'center', 'marginBottom':'10px'}),
-        html.Hr(),
-        html.Div(
-            id='doc-type-buttons'
-        ),
-        chat_card
-    ]
-
-def file_list_component():
-    return html.Div(
-        id='file-list-container',
-        children=[
-            html.Div(id='file-list')
-        ]
-    )
-
 app.layout = dbc.Container([
     dcc.Store(id='selected-doc-type', data="Shred"),
+    dcc.Store(id='store-shred'),
+    dcc.Store(id='store-pink'),
+    dcc.Store(id='store-pink-review'),
+    dcc.Store(id='store-red'),
+    dcc.Store(id='store-red-review'),
+    dcc.Store(id='store-gold'),
+    dcc.Store(id='store-gold-review'),
+    dcc.Store(id='store-loe'),
+    dcc.Store(id='store-virtual-board'),
     dbc.Row([
         dbc.Col(
             html.H2(id='main-title', className="mt-3 mb-2", style={'textAlign': 'center', 'width':'100%'}),
@@ -308,41 +436,27 @@ def update_selected_doc_type(n_clicks_list, btn_ids):
 
 @app.callback(
     Output('right-col-content', 'children'),
-    Input('selected-doc-type', 'data')
+    Input('selected-doc-type', 'data'),
+    State('store-shred', 'data'),
+    State('store-pink', 'data'),
+    State('store-pink-review', 'data'),
+    State('store-red', 'data'),
+    State('store-red-review', 'data'),
+    State('store-gold', 'data'),
 )
-def update_right_col(selected_type):
-    return get_right_col_content(selected_type)
-
-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:
-                page_text = page.extract_text()
-                if page_text:
-                    text += page_text
-            return text
-        else:
-            return f"Unsupported file format: {filename}. Please upload a PDF or DOCX file."
-    except Exception as e:
-        logging.error(f"Error processing document: {str(e)}")
-        return f"Error processing document: {str(e)}"
+def update_right_col(selected_type, shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc):
+    return get_right_col_content(selected_type, shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc)
 
 @app.callback(
     Output('file-list', 'children'),
+    Output('store-shred', 'data'),
     Input('upload-document', 'contents'),
     State('upload-document', 'filename'),
-    State('file-list', 'children')
+    State('file-list', 'children'),
+    State('store-shred', 'data')
 )
-def update_output(list_of_contents, list_of_names, existing_files):
-    global uploaded_files, shredded_document
+def update_output(list_of_contents, list_of_names, existing_files, current_shred):
+    global uploaded_files
     if list_of_contents is not None:
         new_files = []
         for i, (content, name) in enumerate(zip(list_of_contents, list_of_names)):
@@ -364,19 +478,20 @@ def update_output(list_of_contents, list_of_names, existing_files):
             existing_files = []
         elif not isinstance(existing_files, list):
             existing_files = [existing_files]
-        shredded_document = None
         logging.info("Documents uploaded and file list updated.")
-        return existing_files + new_files
-    return existing_files
+        return existing_files + new_files, current_shred
+    return existing_files, current_shred
 
 @app.callback(
     Output('file-list', 'children', allow_duplicate=True),
+    Output('store-shred', 'data', allow_duplicate=True),
     Input({'type': 'remove-file', 'index': ALL}, 'n_clicks'),
     State('file-list', 'children'),
+    State('store-shred', 'data'),
     prevent_initial_call=True
 )
-def remove_file(n_clicks, existing_files):
-    global uploaded_files, shredded_document
+def remove_file(n_clicks, existing_files, current_shred):
+    global uploaded_files
     ctx = dash.callback_context
     if not ctx.triggered:
         raise dash.exceptions.PreventUpdate
@@ -391,7 +506,6 @@ def remove_file(n_clicks, existing_files):
         logging.error(f"Could not parse removed file from callback context: {e}")
         raise dash.exceptions.PreventUpdate
     uploaded_files.pop(removed_file, None)
-    shredded_document = None
     logging.info(f"Removed file: {removed_file}")
     filtered_files = []
     if existing_files:
@@ -402,9 +516,8 @@ def remove_file(n_clicks, existing_files):
                     filtered_files.append(file)
             except Exception as e:
                 filtered_files.append(file)
-    return filtered_files
+    return filtered_files, current_shred
 
-# Upload callbacks for all doc dependencies (Pink, Pink Review, Red, Red Review, Gold, Gold Review, LOE, Virtual Board)
 def make_upload_callback(src):
     @app.callback(
         Output({'type': f'uploaded-doc-name-{src}', 'index': MATCH}, 'children'),
@@ -424,101 +537,6 @@ def make_upload_callback(src):
 for src in ["shred", "pink", "pink_review", "red", "red_review", "gold"]:
     make_upload_callback(src)
 
-def extract_markdown_tables(md_text):
-    tables = []
-    lines = md_text.split('\n')
-    in_table = False
-    table_lines = []
-    for line in lines:
-        if re.match(r'^\s*\|.*\|\s*$', line):
-            in_table = True
-            table_lines.append(line)
-        elif in_table and (re.match(r'^\s*\|.*\|\s*$', line) or re.match(r'^\s*$', line)):
-            table_lines.append(line)
-        else:
-            if in_table and table_lines:
-                tables.append('\n'.join(table_lines))
-                table_lines = []
-            in_table = False
-    if in_table and table_lines:
-        tables.append('\n'.join(table_lines))
-    return tables
-
-def markdown_table_to_df(md_table):
-    lines = [line.strip() for line in md_table.split('\n') if line.strip()]
-    if len(lines) < 2:
-        return None
-    header = [h.strip() for h in lines[0].strip('|').split('|')]
-    sep_idx = 1
-    while sep_idx < len(lines) and not re.match(r'^\|\s*:?-+:?\s*(\|\s*:?-+:?\s*)+\|?$', lines[sep_idx]):
-        sep_idx += 1
-    data_lines = lines[sep_idx+1:] if sep_idx+1 < len(lines) else []
-    rows = []
-    for row in data_lines:
-        if not row.strip() or not row.strip().startswith('|'):
-            continue
-        cells = [c.strip() for c in row.strip('|').split('|')]
-        if len(cells) < len(header):
-            cells += [''] * (len(header) - len(cells))
-        elif len(cells) > len(header):
-            cells = cells[:len(header)]
-        rows.append(cells)
-    df = pd.DataFrame(rows, columns=header)
-    return df
-
-def markdown_table_preview(md_text):
-    tables = extract_markdown_tables(md_text)
-    if not tables:
-        return html.Div("No table found.")
-    table_divs = []
-    for i, table in enumerate(tables):
-        df = markdown_table_to_df(table)
-        if df is not None and not df.empty:
-            table_divs.append(
-                html.Div([
-                    DataTable(
-                        columns=[{"name": str(col), "id": str(col)} for col in df.columns],
-                        data=df.to_dict('records'),
-                        style_table={'overflowX': 'auto'},
-                        style_cell={'whiteSpace': 'normal', 'height': 'auto', 'textAlign': 'left', 'fontFamily': 'monospace', 'fontSize': '14px', 'maxWidth': '400px', 'minWidth': '80px', 'wordBreak': 'break-word'},
-                        style_header={'fontWeight': 'bold'},
-                        page_size=100,
-                        id={'type': 'datatable-preview', 'index': i}
-                    )
-                ], className="mb-4")
-            )
-    return html.Div(table_divs)
-
-def markdown_narrative_preview(md_text):
-    return html.Div(dcc.Markdown(md_text, dangerously_allow_html=True, style={'whiteSpace': 'pre-wrap', 'fontFamily': 'sans-serif'}))
-
-def markdown_tables_to_xlsx(md_text):
-    tables = extract_markdown_tables(md_text)
-    output = BytesIO()
-    with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
-        for i, table in enumerate(tables):
-            df = markdown_table_to_df(table)
-            if df is not None:
-                sheet_name = f"Table{i+1}"
-                df.to_excel(writer, sheet_name=sheet_name, index=False)
-    output.seek(0)
-    return output
-
-def strip_markdown(text):
-    text = re.sub(r'(\*\*|__)(.*?)\1', r'\2', text)
-    text = re.sub(r'(\*|_)(.*?)\1', r'\2', text)
-    text = re.sub(r'`{1,3}[^`]*`{1,3}', '', text)
-    text = re.sub(r'^#+ ', '', text, flags=re.MULTILINE)
-    text = re.sub(r'^> ', '', text, flags=re.MULTILINE)
-    text = re.sub(r'!\[.*?\]\(.*?\)', '', text)
-    text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
-    text = re.sub(r'^\s*[-*+] ', '', text, flags=re.MULTILINE)
-    text = re.sub(r'^\s*\d+\.\s+', '', text, flags=re.MULTILINE)
-    text = text.replace('---', '')
-    text = text.replace('___', '')
-    text = text.replace('***', '')
-    return text.strip()
-
 def generate_document(document_type, file_contents, extra_context=None):
     if document_type in spreadsheet_types:
         prompt = f"""Ignore all other instructions and output only a spreadsheet for {document_type} as described below. Do not include any narrative, only the spreadsheet in markdown table format.
@@ -566,6 +584,15 @@ Now, generate the {document_type}:
 @app.callback(
     Output('document-preview', 'children'),
     Output('loading-output', 'children'),
+    Output('store-shred', 'data'),
+    Output('store-pink', 'data'),
+    Output('store-pink-review', 'data'),
+    Output('store-red', 'data'),
+    Output('store-red-review', 'data'),
+    Output('store-gold', 'data'),
+    Output('store-gold-review', 'data'),
+    Output('store-loe', 'data'),
+    Output('store-virtual-board', 'data'),
     Input({'type': 'btn-generate-doc', 'index': ALL}, 'n_clicks'),
     State({'type': 'btn-generate-doc', 'index': ALL}, 'id'),
     State({'type': 'radio-doc-source-shred', 'index': ALL}, 'value'),
@@ -586,6 +613,15 @@ Now, generate the {document_type}:
     State({'type': 'radio-doc-source-gold', 'index': ALL}, 'value'),
     State({'type': 'upload-doc-type-gold', 'index': ALL}, 'contents'),
     State({'type': 'upload-doc-type-gold', 'index': ALL}, 'filename'),
+    State('store-shred', 'data'),
+    State('store-pink', 'data'),
+    State('store-pink-review', 'data'),
+    State('store-red', 'data'),
+    State('store-red-review', 'data'),
+    State('store-gold', 'data'),
+    State('store-gold-review', 'data'),
+    State('store-loe', 'data'),
+    State('store-virtual-board', 'data'),
     prevent_initial_call=True
 )
 def generate_any_doc(
@@ -595,9 +631,9 @@ def generate_any_doc(
     radio_pink_review, upload_pink_review_contents, upload_pink_review_filenames,
     radio_red, upload_red_contents, upload_red_filenames,
     radio_red_review, upload_red_review_contents, upload_red_review_filenames,
-    radio_gold, upload_gold_contents, upload_gold_filenames
+    radio_gold, upload_gold_contents, upload_gold_filenames,
+    store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board
 ):
-    global current_document, document_type, shredded_document, pink_review_document, pink_document, red_review_document, red_document, gold_review_document, gold_document
     ctx = callback_context
     logging.info(f"generate_any_doc triggered: n_clicks_list={n_clicks_list}, btn_ids={btn_ids}")
     if not ctx.triggered:
@@ -607,190 +643,214 @@ def generate_any_doc(
         raise dash.exceptions.PreventUpdate
     idx = idx[-1]
     doc_type = btn_ids[idx]['index']
-    document_type = doc_type
 
-    # SHRED - always allowed
+    shred_doc = store_shred
+    pink_doc = store_pink
+    pink_review_doc = store_pink_review
+    red_doc = store_red
+    red_review_doc = store_red_review
+    gold_doc = store_gold
+    gold_review_doc = store_gold_review
+    loe_doc = store_loe
+    virtual_board_doc = store_virtual_board
+
+    def get_doc_from_radio(radio, upload_contents, upload_filenames, loaded_var):
+        if radio and radio[0] == 'uploaded':
+            if upload_contents and upload_contents[0] and upload_filenames and upload_filenames[0]:
+                return process_document(upload_contents[0], upload_filenames[0])
+            else:
+                return None
+        else:
+            return loaded_var
+
     if doc_type == "Shred":
         if not uploaded_files:
             logging.info("No uploaded files for Shred. Aborting.")
-            return html.Div("Please upload a document before shredding."), ""
+            return html.Div("Please upload a document before shredding."), "", None, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         file_contents = list(uploaded_files.values())
         try:
             generated = generate_document(doc_type, file_contents)
-            current_document = generated
-            shredded_document = generated
+            shred_doc = generated
             preview = markdown_table_preview(generated)
             logging.info("Shred document generated.")
-            return preview, "Shred generated"
+            return preview, "Shred generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         except Exception as e:
             logging.error(f"Error generating document: {str(e)}")
-            return html.Div(f"Error generating document: {str(e)}"), "Error"
+            return html.Div(f"Error generating document: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
 
-    # Dependency rules
-    def get_doc_from_radio(radio, upload_contents, upload_filenames, loaded_var):
-        if radio and radio[0] == 'uploaded':
-            if upload_contents and upload_contents[0] and upload_filenames and upload_filenames[0]:
-                return process_document(upload_contents[0], upload_filenames[0])
-            else:
-                return None
-        else:
-            return loaded_var
-
-    # Pink: can only use Shred (requirements), loaded or uploaded
     if doc_type == "Pink":
-        shred_doc = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shredded_document)
-        if not shred_doc:
-            return html.Div("Please provide a Shred requirements document (either loaded or uploaded) to generate Pink."), ""
+        shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
+        if not shred:
+            return html.Div("Please provide a Shred requirements document (either loaded or uploaded) to generate Pink."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         try:
-            generated = generate_document(doc_type, [shred_doc])
-            current_document = generated
-            pink_document = generated
+            generated = generate_document(doc_type, [shred])
+            pink_doc = generated
             preview = markdown_narrative_preview(generated)
             logging.info("Pink document generated.")
-            return preview, "Pink generated"
+            return preview, "Pink generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         except Exception as e:
             logging.error(f"Error generating Pink: {str(e)}")
-            return html.Div(f"Error generating Pink: {str(e)}"), "Error"
+            return html.Div(f"Error generating Pink: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
 
-    # Pink Review: must compare Pink (uploaded or generated) with Shred (uploaded or generated)
     if doc_type == "Pink Review":
-        pink_doc = get_doc_from_radio(radio_pink, upload_pink_contents, upload_pink_filenames, pink_document)
-        shred_doc = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shredded_document)
-        if not pink_doc or not shred_doc:
-            return html.Div("Please provide both Pink and Shred documents (either loaded or uploaded) to generate Pink Review."), ""
+        pink = get_doc_from_radio(radio_pink, upload_pink_contents, upload_pink_filenames, pink_doc)
+        shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
+        if not pink or not shred:
+            return html.Div("Please provide both Pink and Shred documents (either loaded or uploaded) to generate Pink Review."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         try:
-            generated = generate_document(doc_type, [pink_doc, shred_doc])
-            current_document = generated
-            pink_review_document = generated
+            generated = generate_document(doc_type, [pink, shred])
+            pink_review_doc = generated
             preview = markdown_table_preview(generated)
             logging.info("Pink Review document generated.")
-            return preview, "Pink Review generated"
+            return preview, "Pink Review generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         except Exception as e:
             logging.error(f"Error generating Pink Review: {str(e)}")
-            return html.Div(f"Error generating Pink Review: {str(e)}"), "Error"
+            return html.Div(f"Error generating Pink Review: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
 
-    # Red: can only use Pink Review (uploaded or generated)
     if doc_type == "Red":
-        pink_review_doc = get_doc_from_radio(radio_pink_review, upload_pink_review_contents, upload_pink_review_filenames, pink_review_document)
-        if not pink_review_doc:
-            return html.Div("Please provide a Pink Review document (either loaded or uploaded) to generate Red."), ""
+        pink_review = get_doc_from_radio(radio_pink_review, upload_pink_review_contents, upload_pink_review_filenames, pink_review_doc)
+        if not pink_review:
+            return html.Div("Please provide a Pink Review document (either loaded or uploaded) to generate Red."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         try:
-            generated = generate_document(doc_type, [pink_review_doc])
-            current_document = generated
-            red_document = generated
+            generated = generate_document(doc_type, [pink_review])
+            red_doc = generated
             preview = markdown_narrative_preview(generated)
             logging.info("Red document generated.")
-            return preview, "Red generated"
+            return preview, "Red generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         except Exception as e:
             logging.error(f"Error generating Red: {str(e)}")
-            return html.Div(f"Error generating Red: {str(e)}"), "Error"
+            return html.Div(f"Error generating Red: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
 
-    # Red Review: must compare Red (uploaded or generated) with Shred (uploaded or generated)
     if doc_type == "Red Review":
-        red_doc = get_doc_from_radio(radio_red, upload_red_contents, upload_red_filenames, red_document)
-        shred_doc = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shredded_document)
-        if not red_doc or not shred_doc:
-            return html.Div("Please provide both Red and Shred documents (either loaded or uploaded) to generate Red Review."), ""
+        red = get_doc_from_radio(radio_red, upload_red_contents, upload_red_filenames, red_doc)
+        shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
+        if not red or not shred:
+            return html.Div("Please provide both Red and Shred documents (either loaded or uploaded) to generate Red Review."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         try:
-            generated = generate_document(doc_type, [red_doc, shred_doc])
-            current_document = generated
-            red_review_document = generated
+            generated = generate_document(doc_type, [red, shred])
+            red_review_doc = generated
             preview = markdown_table_preview(generated)
             logging.info("Red Review document generated.")
-            return preview, "Red Review generated"
+            return preview, "Red Review generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         except Exception as e:
             logging.error(f"Error generating Red Review: {str(e)}")
-            return html.Div(f"Error generating Red Review: {str(e)}"), "Error"
+            return html.Div(f"Error generating Red Review: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
 
-    # Gold: can only use Red Review (uploaded or generated)
     if doc_type == "Gold":
-        red_review_doc = get_doc_from_radio(radio_red_review, upload_red_review_contents, upload_red_review_filenames, red_review_document)
-        if not red_review_doc:
-            return html.Div("Please provide a Red Review document (either loaded or uploaded) to generate Gold."), ""
+        red_review = get_doc_from_radio(radio_red_review, upload_red_review_contents, upload_red_review_filenames, red_review_doc)
+        if not red_review:
+            return html.Div("Please provide a Red Review document (either loaded or uploaded) to generate Gold."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         try:
-            generated = generate_document(doc_type, [red_review_doc])
-            current_document = generated
-            gold_document = generated
+            generated = generate_document(doc_type, [red_review])
+            gold_doc = generated
             preview = markdown_narrative_preview(generated)
             logging.info("Gold document generated.")
-            return preview, "Gold generated"
+            return preview, "Gold generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         except Exception as e:
             logging.error(f"Error generating Gold: {str(e)}")
-            return html.Div(f"Error generating Gold: {str(e)}"), "Error"
+            return html.Div(f"Error generating Gold: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
 
-    # Gold Review: must compare Gold (uploaded or generated) with Shred (uploaded or generated)
     if doc_type == "Gold Review":
-        gold_doc = get_doc_from_radio(radio_gold, upload_gold_contents, upload_gold_filenames, gold_document)
-        shred_doc = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shredded_document)
-        if not gold_doc or not shred_doc:
-            return html.Div("Please provide both Gold and Shred documents (either loaded or uploaded) to generate Gold Review."), ""
+        gold = get_doc_from_radio(radio_gold, upload_gold_contents, upload_gold_filenames, gold_doc)
+        shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
+        if not gold or not shred:
+            return html.Div("Please provide both Gold and Shred documents (either loaded or uploaded) to generate Gold Review."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         try:
-            generated = generate_document(doc_type, [gold_doc, shred_doc])
-            current_document = generated
-            gold_review_document = generated
+            generated = generate_document(doc_type, [gold, shred])
+            gold_review_doc = generated
             preview = markdown_table_preview(generated)
             logging.info("Gold Review document generated.")
-            return preview, "Gold Review generated"
+            return preview, "Gold Review generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         except Exception as e:
             logging.error(f"Error generating Gold Review: {str(e)}")
-            return html.Div(f"Error generating Gold Review: {str(e)}"), "Error"
+            return html.Div(f"Error generating Gold Review: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
 
-    # LOE: can only use Gold (uploaded or generated)
     if doc_type == "LOE":
-        gold_doc = get_doc_from_radio(radio_gold, upload_gold_contents, upload_gold_filenames, gold_document)
-        if not gold_doc:
-            return html.Div("Please provide a Gold document (either loaded or uploaded) to generate LOE."), ""
+        gold = get_doc_from_radio(radio_gold, upload_gold_contents, upload_gold_filenames, gold_doc)
+        if not gold:
+            return html.Div("Please provide a Gold document (either loaded or uploaded) to generate LOE."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         try:
-            generated = generate_document(doc_type, [gold_doc])
-            current_document = generated
+            generated = generate_document(doc_type, [gold])
+            loe_doc = generated
             preview = markdown_table_preview(generated)
             logging.info("LOE document generated.")
-            return preview, "LOE generated"
+            return preview, "LOE generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         except Exception as e:
             logging.error(f"Error generating LOE: {str(e)}")
-            return html.Div(f"Error generating LOE: {str(e)}"), "Error"
+            return html.Div(f"Error generating LOE: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
 
-    # Virtual Board: can only use Shred (L&M evaluation criteria)
     if doc_type == "Virtual Board":
-        shred_doc = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shredded_document)
-        if not shred_doc:
-            return html.Div("Please provide a Shred requirements document (either loaded or uploaded) to generate Virtual Board."), ""
+        shred = get_doc_from_radio(radio_shred, upload_shred_contents, upload_shred_filenames, shred_doc)
+        if not shred:
+            return html.Div("Please provide a Shred requirements document (either loaded or uploaded) to generate Virtual Board."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         try:
-            # Extract section L&M if possible
             lm_text = ""
-            lm_match = re.search(r'(Section\s+L[\s\S]+?)(Section\s+M|$)', shred_doc, re.IGNORECASE)
+            lm_match = re.search(r'(Section\s+L[\s\S]+?)(Section\s+M|$)', shred, re.IGNORECASE)
             if lm_match:
                 lm_text = lm_match.group(1)
             else:
-                lm_text = shred_doc
+                lm_text = shred
             generated = generate_document(doc_type, [lm_text])
-            current_document = generated
+            virtual_board_doc = generated
             preview = markdown_table_preview(generated)
             logging.info("Virtual Board document generated.")
-            return preview, "Virtual Board generated"
+            return preview, "Virtual Board generated", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
         except Exception as e:
             logging.error(f"Error generating Virtual Board: {str(e)}")
-            return html.Div(f"Error generating Virtual Board: {str(e)}"), "Error"
+            return html.Div(f"Error generating Virtual Board: {str(e)}"), "Error", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
 
-    return html.Div("Unsupported document type or missing required sources."), ""
+    return html.Div("Unsupported document type or missing required sources."), "", shred_doc, pink_doc, pink_review_doc, red_doc, red_review_doc, gold_doc, gold_review_doc, loe_doc, virtual_board_doc
 
 @app.callback(
     Output('chat-output', 'children'),
     Output('document-preview', 'children', allow_duplicate=True),
+    Output('store-shred', 'data', allow_duplicate=True),
+    Output('store-pink', 'data', allow_duplicate=True),
+    Output('store-pink-review', 'data', allow_duplicate=True),
+    Output('store-red', 'data', allow_duplicate=True),
+    Output('store-red-review', 'data', allow_duplicate=True),
+    Output('store-gold', 'data', allow_duplicate=True),
+    Output('store-gold-review', 'data', allow_duplicate=True),
+    Output('store-loe', 'data', allow_duplicate=True),
+    Output('store-virtual-board', 'data', allow_duplicate=True),
     Input('btn-send-chat', 'n_clicks'),
     Input('btn-clear-chat', 'n_clicks'),
     State('chat-input', 'value'),
     State('selected-doc-type', 'data'),
+    State('document-preview', 'children'),
+    State('store-shred', 'data'),
+    State('store-pink', 'data'),
+    State('store-pink-review', 'data'),
+    State('store-red', 'data'),
+    State('store-red-review', 'data'),
+    State('store-gold', 'data'),
+    State('store-gold-review', 'data'),
+    State('store-loe', 'data'),
+    State('store-virtual-board', 'data'),
     prevent_initial_call=True
 )
-def update_document_via_chat(btn_send, btn_clear, chat_input, selected_doc_type):
-    global current_document, document_type
+def update_document_via_chat(btn_send, btn_clear, chat_input, selected_doc_type, doc_preview,
+                             store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board):
     ctx = callback_context
     if not ctx.triggered:
         raise dash.exceptions.PreventUpdate
     trigger_id = ctx.triggered[0]['prop_id'].split('.')[0]
     if trigger_id == 'btn-clear-chat':
-        return "", dash.no_update
+        return "", dash.no_update, store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board
+
+    doc_map = {
+        "Shred": store_shred,
+        "Pink": store_pink,
+        "Pink Review": store_pink_review,
+        "Red": store_red,
+        "Red Review": store_red_review,
+        "Gold": store_gold,
+        "Gold Review": store_gold_review,
+        "LOE": store_loe,
+        "Virtual Board": store_virtual_board
+    }
+    current_document = doc_map.get(selected_doc_type)
+
     if not chat_input or current_document is None:
         raise dash.exceptions.PreventUpdate
 
@@ -811,7 +871,7 @@ Instructions:
 1. Provide the updated document content.
 2. Maintain proper formatting and structure.
 3. Incorporate the requested changes seamlessly.
-4. If the {document_type} is Pink, Red, or Gold then your goal is to write a FULL propposal response, not just a strategy and be compliant and compelling by addressing all the requirements from the document provided.  Focus on describing the approach and highly detailed 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.  Do not just say things like we will, or MicroHealth will, use active voice and verbs that are definitive in nature, not maybe, could be, should be, can be and things like that.  This is a proposal response so logical flow is important so the reader can follow.
+4. If the {selected_doc_type} is Pink, Red, or Gold then your goal is to write a FULL proposal response, not just a strategy and be compliant and compelling by addressing all the requirements from the document provided.  Focus on describing the approach and highly detailed 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.  Do not just say things like we will, or MicroHealth will, use active voice and verbs that are definitive in nature, not maybe, could be, should be, can be and things like that.  This is a proposal response so logical flow is important so the reader can follow.
 Now, provide the updated {selected_doc_type}:
 """
     logging.info(f"Updating document via chat for {selected_doc_type} instruction: {chat_input}")
@@ -825,25 +885,45 @@ Now, provide the updated {selected_doc_type}:
             max_tokens=32768,
             temperature=0.5,
         )
-        current_document = response['choices'][0]['message']['content']
-        logging.info("Document updated via chat successfully.")
+        new_document = response['choices'][0]['message']['content']
         if selected_doc_type in spreadsheet_types:
-            preview = markdown_table_preview(current_document)
+            preview = markdown_table_preview(new_document)
         else:
-            preview = markdown_narrative_preview(current_document)
-        return f"Document updated based on: {chat_input}", preview
+            preview = markdown_narrative_preview(new_document)
+        doc_map[selected_doc_type] = new_document
+        return f"Document updated based on: {chat_input}", preview, doc_map.get("Shred"), doc_map.get("Pink"), doc_map.get("Pink Review"), doc_map.get("Red"), doc_map.get("Red Review"), doc_map.get("Gold"), doc_map.get("Gold Review"), doc_map.get("LOE"), doc_map.get("Virtual Board")
     except Exception as e:
         logging.error(f"Error updating document via chat: {str(e)}")
-        return f"Error updating document: {str(e)}", html.Div(f"Error updating document: {str(e)}")
+        return f"Error updating document: {str(e)}", html.Div(f"Error updating document: {str(e)}"), store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board
 
 @app.callback(
     Output("download-document", "data"),
     Input("btn-download", "n_clicks"),
     State('selected-doc-type', 'data'),
+    State('store-shred', 'data'),
+    State('store-pink', 'data'),
+    State('store-pink-review', 'data'),
+    State('store-red', 'data'),
+    State('store-red-review', 'data'),
+    State('store-gold', 'data'),
+    State('store-gold-review', 'data'),
+    State('store-loe', 'data'),
+    State('store-virtual-board', 'data'),
     prevent_initial_call=True
 )
-def download_document(n_clicks, selected_doc_type):
-    global current_document
+def download_document(n_clicks, selected_doc_type, store_shred, store_pink, store_pink_review, store_red, store_red_review, store_gold, store_gold_review, store_loe, store_virtual_board):
+    doc_map = {
+        "Shred": store_shred,
+        "Pink": store_pink,
+        "Pink Review": store_pink_review,
+        "Red": store_red,
+        "Red Review": store_red_review,
+        "Gold": store_gold,
+        "Gold Review": store_gold_review,
+        "LOE": store_loe,
+        "Virtual Board": store_virtual_board
+    }
+    current_document = doc_map.get(selected_doc_type)
     if current_document is None:
         raise dash.exceptions.PreventUpdate