Update app for Hugging Face

.gitignore

@@ -0,0 +1,27 @@
+# Environment variables
+.env
+
+# Log files
+*.log
+
+# Python cache
+__pycache__/
+*.pyc
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Test documents
+test_docs/
+
+# IDE settings
+.vscode/
+
+# Streamlit secrets
+.streamlit/secrets.toml
+
+# Exclude binary files
+*.pdf
+*.docx

README.md

@@ -0,0 +1,11 @@
+
+---
+title: dissistant
+emoji: 🚀
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+sdk_version: 1.29.0
+python_version: 3.9
+app_file: app.py
+---

app.py

@@ -0,0 +1,207 @@
+import streamlit as st
+import os
+import tempfile
+from pathlib import Path
+import time
+import logging
+import asyncio
+
+# Import modules
+from modules.llm_interface import analyze_with_llm
+from modules.report_generator import generate_report
+
+# Import configuration
+from config import settings
+
+# Get logger
+logger = logging.getLogger(__name__)
+
+# --- Password Authentication Function ---
+def check_authentication():
+    """Returns `True` if the user is authenticated."""
+    expected_password = st.secrets.get("APP_PASSWORD")
+
+    if not expected_password:
+        st.session_state.authenticated = True
+        return True
+
+    if "authenticated" not in st.session_state:
+        st.session_state.authenticated = False
+
+    if st.session_state.authenticated:
+        return True
+
+    with st.form(key="password_form"):
+        st.subheader("Enter Password to Access")
+        password_attempt = st.text_input("Password", type="password", key="password_input_field")
+        login_button = st.form_submit_button("Login")
+
+    if login_button:
+        if password_attempt == expected_password:
+            st.session_state.authenticated = True
+            st.rerun() 
+        else:
+            st.error("Incorrect password. Please try again.")
+            return False
+    return False
+
+# Set page configuration
+st.set_page_config(
+    page_title="Graduate Center Dissertation Review Tool",
+    page_icon="📚",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main .block-container {
+        padding-top: 2rem;
+        padding-bottom: 2rem;
+    }
+    h1, h2, h3 {
+        margin-bottom: 1rem;
+    }
+    .stProgress > div > div > div {
+        background-color: #4CAF50;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if "analysis_results" not in st.session_state:
+    st.session_state.analysis_results = None
+if "report_generated" not in st.session_state:
+    st.session_state.report_generated = False
+
+# Title and description
+st.title("Graduate Center Dissertation Review Tool")
+st.markdown("""
+This tool automatically checks dissertations and theses for formatting and citation rules.
+Upload your document to receive a detailed report.
+""")
+
+# Sidebar for configuration
+with st.sidebar:
+    st.header("Configuration")
+    
+    # Reset button
+    if st.button("Start Over"):
+        for key in st.session_state.keys():
+            del st.session_state[key]
+        st.rerun()
+
+if check_authentication():
+    # Main content area
+    tab1, tab2 = st.tabs(["Document Upload", "Review Report"])
+
+    with tab1:
+        st.header("Upload Your Document")
+        
+        uploaded_file = st.file_uploader("Choose a PDF or Word document", type=["pdf", "docx"])
+        
+        if uploaded_file is not None:
+            # Display file info
+            file_details = {
+                "Filename": uploaded_file.name,
+                "File size": f"{uploaded_file.size / 1024:.2f} KB",
+                "File type": uploaded_file.type
+            }
+            
+            st.write("File Details:")
+            for key, value in file_details.items():
+                st.write(f"- {key}: {value}")
+            
+            # Process button
+            if st.button("Process Document"):
+                logger.info(f"Processing document: {uploaded_file.name}")
+                try:
+                    with st.spinner("Processing document..."):
+                        # Process document
+                        progress_bar = st.progress(0)
+                        
+                        # Step 1: Read file bytes
+                        pdf_bytes = uploaded_file.getvalue()
+                        progress_bar.progress(25)
+                        time.sleep(0.5)  # Simulate processing time
+                        
+                        # Step 2: Metadata extraction
+                        logger.info("Extracting metadata...")
+                        st.write("Extracting metadata...")
+                        metadata = {"title": uploaded_file.name} # Dummy metadata
+                        progress_bar.progress(50)
+                        time.sleep(0.5)  # Simulate processing time
+                        
+                        # Step 3: LLM analysis
+                        logger.info("Performing analysis with LLM...")
+                        st.write("Performing analysis with LLM...")
+                        analysis_results = analyze_with_llm(
+                            pdf_file=pdf_bytes,
+                            metadata=metadata
+                        )
+                        st.session_state.analysis_results = analysis_results
+                        progress_bar.progress(100)
+                        
+                        # Generate report
+                        logger.info("Generating report...")
+                        st.session_state.report = generate_report(analysis_results)
+                        
+                        st.session_state.report_generated = True
+                        
+                        # Switch to report tab
+                        st.success("Document processed successfully! View the compliance report in the next tab.")
+                        
+                except Exception as e:
+                    logger.error(f"An error occurred during processing: {str(e)}", exc_info=True)
+                    st.error(f"An error occurred during processing: {str(e)}")
+
+    with tab2:
+        st.header("Review Report")
+        
+        if not st.session_state.report_generated:
+            st.info("Upload and process a document to generate a review report.")
+        else:
+            # Display summary
+            st.subheader("Summary")
+            summary = st.session_state.analysis_results.get("summary", {})
+            st.write(f"**Overall Assessment**: {summary.get('overall_assessment', 'N/A')}")
+            st.write(f"**Total Issues**: {summary.get('total_issues', 'N/A')}")
+            st.write(f"**Critical Issues**: {summary.get('critical_issues', 'N/A')}")
+            st.write(f"**Warning Issues**: {summary.get('warning_issues', 'N/A')}")
+            
+            # Display recommendations
+            st.subheader("Recommendations")
+            recommendations = st.session_state.analysis_results.get("recommendations", [])
+            if recommendations:
+                for rec in recommendations:
+                    st.write(f"- {rec}")
+            else:
+                st.write("No recommendations.")
+                
+            # Display detailed report
+            st.subheader("Detailed Report")
+            issues = st.session_state.analysis_results.get("issues", [])
+            if issues:
+                for issue in issues:
+                    severity = issue.get('severity', 'N/A').lower()
+                    message = f"**{issue.get('severity', 'N/A').upper()}**: {issue.get('message', 'N/A')}"
+
+                    if severity == 'critical':
+                        st.error(message)
+                    elif severity == 'warning':
+                        st.warning(message)
+                    elif severity == 'info':
+                        st.info(message)
+                    else:
+                        st.success(message)
+
+                    st.write(f"**Location**: {issue.get('location', 'N/A')}")
+                    st.write(f"**Suggestion**: {issue.get('suggestion', 'N/A')}")
+                    st.divider()
+            else:
+                st.success("No issues found.")
+
+# Footer
+st.markdown("---")
+st.markdown("© Graduate Center, CUNY. Developed to assist with dissertation and thesis review.")

config.py

@@ -0,0 +1,181 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+import os
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional
+from pydantic import BaseModel, Field
+
+# Logging configuration
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler("dissistant.log"),
+        logging.StreamHandler()
+    ]
+)
+
+# Base directory
+BASE_DIR = Path(__file__).resolve().parent
+
+class Settings(BaseModel):
+    """Application settings"""
+    # Application settings
+    app_name: str = "Graduate Center Dissertation Compliance Assistant"
+    description: str = "A tool to check dissertations and theses for compliance with Graduate Center formatting and citation rules."
+    version: str = "0.1.0"
+    debug: bool = os.getenv("DEBUG", "False").lower() == "true"  # Default to False if not set
+
+    # Paths
+    rules_dir: Path = BASE_DIR / "rules"
+    formatting_rules_path: Path = rules_dir / "formatting_rules.md"
+    citation_rules_path: Path = rules_dir / "citation_rules.md"
+    metadata_rules_path: Path = rules_dir / "metadata_rules.md"
+    
+    # LLM settings
+    llm_provider: str = os.getenv("LLM_PROVIDER", "openrouter").lower()  # 'local', 'openai', or 'openrouter'
+    llm_model_name: str = os.getenv("LLM_MODEL_NAME", "google/gemini-2.5-pro")
+    llm_base_url: str = os.getenv("LLM_API_BASE", "https://openrouter.ai/api/v1")
+    llm_api_key: str = os.getenv("LLM_API_KEY", "lm-studio")  # Default for local LM Studio
+    
+    # OpenAI specific settings
+    openai_api_key: Optional[str] = os.getenv("OPENAI_API_KEY")
+    openai_model: str = os.getenv("OPENAI_MODEL", "gpt-4")
+
+    # OpenRouter specific settings
+    openrouter_api_key: Optional[str] = os.getenv("OPENROUTER_API_KEY")
+    
+    # Document processing settings
+    max_file_size_mb: int = 50  # Maximum file size in MB
+    supported_file_types: List[str] = ["pdf", "docx"]
+    
+    # Citation styles
+    citation_styles: List[str] = ["APA", "MLA", "Chicago", "Custom"]
+    default_citation_style: str = "APA"
+    
+    # Department-specific settings
+    departments: List[str] = [
+        "General",
+        "English",
+        "History",
+        "Psychology",
+        "Computer Science",
+        "Other"
+    ]
+
+    # LLM prompt templates
+    formatting_analysis_template: str = """
+    You are an expert in academic document formatting. Analyze the following document excerpt for compliance with the institutional formatting rules.
+    
+    FORMATTING RULES:
+    {formatting_rules}
+    
+    DOCUMENT METADATA:
+    {document_metadata}
+    
+    DOCUMENT EXCERPT:
+    {document_excerpt}
+    
+    Identify any formatting issues in the document. For each issue, provide:
+    1. A description of the issue
+    2. The location in the document
+    3. The specific rule that is violated
+    4. A suggestion for how to fix the issue
+    5. The severity of the issue (critical, warning, or info)
+    
+    Format your response as a JSON array of issues, with each issue having the following fields:
+    - "message": A clear description of the issue
+    - "location": Where in the document the issue occurs
+    - "rule": The specific rule that is violated
+    - "suggestion": How to fix the issue
+    - "severity": The severity level (critical, warning, or info)
+    
+    If no issues are found, return an empty array.
+    """
+    
+    citation_analysis_template: str = """
+    You are an expert in academic citation styles. Analyze the following document excerpt for compliance with the specified citation style.
+    
+    CITATION STYLE: {citation_style}
+    
+    CITATION STYLE GUIDELINES:
+    {citation_guidelines}
+    
+    DOCUMENT EXCERPT:
+    {document_excerpt}
+    
+    Identify any citation issues in the document. For each issue, provide:
+    1. A description of the issue
+    2. The problematic citation
+    3. The page or location where it appears
+    4. A suggestion for how to fix the issue
+    5. The severity of the issue (critical, warning, or info)
+    
+    Format your response as a JSON array of issues, with each issue having the following fields:
+    - "message": A clear description of the issue
+    - "citation": The problematic citation
+    - "page": The page or location where it appears
+    - "suggestion": How to fix the issue
+    - "severity": The severity level (critical, warning, or info)
+    
+    If no issues are found, return an empty array.
+    """
+    
+    metadata_analysis_template: str = """
+    You are an expert in academic document structure. Analyze the following document front matter for compliance with the institutional metadata requirements.
+    
+    METADATA REQUIREMENTS:
+    {metadata_requirements}
+    
+    DOCUMENT FRONT MATTER:
+    {front_matter}
+    
+    Identify any metadata or front matter issues in the document. For each issue, provide:
+    1. A description of the issue
+    2. The specific element that is problematic
+    3. A suggestion for how to fix the issue
+    4. The severity of the issue (critical, warning, or info)
+    
+    Format your response as a JSON array of issues, with each issue having the following fields:
+    - "message": A clear description of the issue
+    - "element": The specific element that is problematic
+    - "suggestion": How to fix the issue
+    - "severity": The severity level (critical, warning, or info)
+    
+    If no issues are found, return an empty array.
+    """
+    
+    overall_analysis_template: str = """
+    You are an expert in academic document formatting and citation. Review the following analysis results and provide an overall assessment of the document's compliance with institutional requirements.
+    
+    FORMATTING ISSUES:
+    {formatting_issues}
+    
+    CITATION ISSUES:
+    {citation_issues}
+    
+    METADATA ISSUES:
+    {metadata_issues}
+    
+    Provide:
+    1. An overall assessment of the document's compliance
+    2. A list of key recommendations for improving the document
+    
+    Format your response as a JSON object with the following fields:
+    - "overall_assessment": A paragraph summarizing the document's compliance status
+    - "recommendations": An array of specific recommendations for improving the document
+    
+    Be constructive and helpful in your assessment and recommendations.
+    """
+
+# Instantiate settings
+settings = Settings()
+
+if __name__ == "__main__":
+    # Print out the settings for verification if run directly
+    print("Application Settings:")
+    for field_name, value in settings.model_dump().items():
+        if not isinstance(value, str) or len(value) < 100:  # Skip printing long strings like templates
+            print(f"  {field_name}: {value}")

dissistant.pid

@@ -0,0 +1 @@
+7465

modules/llm_interface.py

@@ -0,0 +1,158 @@
+import logging
+from typing import Dict, Any
+from config import settings
+import xml.etree.ElementTree as ET
+from openai import OpenAI
+import base64
+import re
+
+logger = logging.getLogger(__name__)
+
+def _extract_xml_block(text: str, tag_name: str) -> str:
+    """
+    Extracts the last complete XML block from a string, ignoring surrounding text.
+    """
+    # This regex finds all occurrences of the specified XML block
+    matches = re.findall(f"<{tag_name}.*?</{tag_name}>", text, re.DOTALL)
+    if matches:
+        # Return the last match, which should be the assistant's response
+        return matches[-1]
+    logger.error(f"Could not find <{tag_name}> block in text: {text}")
+    return ""
+
+def analyze_with_llm(
+    pdf_file: Any,
+    metadata: Dict[str, Any]
+) -> Dict[str, Any]:
+    """
+    Perform compliance analysis with an LLM using a single, unified prompt.
+    """
+    logger.info("Performing compliance analysis with LLM.")
+
+    # Create a unified prompt
+    unified_prompt = f"""
+You are an expert in academic document formatting and citation. Your goal is to analyze the user's document for compliance with the Graduate Center's formatting rules and generate a comprehensive compliance report in XML format.
+
+Your response MUST be in the following XML format. Do not include any other text or explanations outside of the XML structure.
+
+<compliance_report>
+    <summary>
+        <overall_assessment></overall_assessment>
+        <total_issues></total_issues>
+        <critical_issues></critical_issues>
+        <warning_issues></warning_issues>
+    </summary>
+    <recommendations>
+        <recommendation></recommendation>
+    </recommendations>
+    <issues>
+        <issue severity="critical/warning/info">
+            <message></message>
+            <location></location>
+            <suggestion></suggestion>
+        </issue>
+    </issues>
+</compliance_report>
+
+**Formatting Rules to Enforce**
+
+{get_formatting_rules()}
+
+**Document Metadata**
+
+{metadata}
+
+**Instructions**
+
+Please analyze the attached PDF document and generate the compliance report. 
+
+**Important Considerations for Analysis:**
+*   **Citation Style and Department:** Determine the citation style (e.g., APA, MLA, Chicago) and the author's department from the document's content. The document should follow the style manual for its discipline.
+*   **Page Numbering:** When reporting the location of an issue, use the page number exactly as it is written in the document (e.g., 'vii', '12'). Do not use the PDF reader's page count (unless necessary to clarify).
+*   **Visual Formatting:** When assessing visual properties like line spacing, margins, or font size from a PDF, be aware that text extraction can be imperfect. Base your findings on clear and consistent evidence throughout the document. Do not flag minor variations that could be due to PDF rendering. For example, only flag a line spacing issue if it is consistently incorrect across multiple pages and sections. Assume line spacing is correct unless it is obviously and consistently wrong.
+*   **Rule Interpretation:** Apply the formatting rules strictly but fairly. If a rule is ambiguous, note the ambiguity in your assessment.
+*   **Completeness:** Ensure that you check every rule against the document and that your report is complete.
+"""
+
+    # Initialize the OpenAI client
+    client = OpenAI(
+        base_url=settings.llm_base_url,
+        api_key=settings.openrouter_api_key,
+    )
+
+    # Read the PDF and encode it as base64
+    base64_pdf = base64.b64encode(pdf_file).decode('utf-8')
+
+    try:
+        completion = client.chat.completions.create(
+            model=settings.llm_model_name,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": unified_prompt},
+                        {
+                            "type": "file",
+                            "file": {
+                                "file_data": f"data:application/pdf;base64,{base64_pdf}"
+                            }
+                        }
+                    ],
+                }
+            ],
+        )
+        raw_response = completion.choices[0].message.content
+    except Exception as e:
+        logger.error(f"An error occurred: {e}")
+        return {"error": "An error occurred while communicating with the LLM."}
+
+    clean_xml = _extract_xml_block(raw_response, "compliance_report")
+    if not clean_xml:
+        logger.error("Could not extract <compliance_report> XML block from the response.")
+        return {"error": "Could not extract <compliance_report> XML block from the response."}
+
+    logger.info(f"Final assembled report:\n{clean_xml}")
+    
+    # Parse the final XML output
+    try:
+        root = ET.fromstring(clean_xml)
+        
+        summary_node = root.find("summary")
+        summary = {
+            "overall_assessment": summary_node.findtext("overall_assessment", "No assessment available."),
+            "total_issues": summary_node.findtext("total_issues", "N/A"),
+            "critical_issues": summary_node.findtext("critical_issues", "N/A"),
+            "warning_issues": summary_node.findtext("warning_issues", "N/A"),
+        } if summary_node is not None else {}
+
+        issues = []
+        for issue_node in root.findall(".//issue"):
+            issues.append({
+                "severity": issue_node.get("severity"),
+                "message": issue_node.findtext("message"),
+                "location": issue_node.findtext("location"),
+                "suggestion": issue_node.findtext("suggestion"),
+            })
+
+        recommendations = [rec.text for rec in root.findall(".//recommendation")]
+
+        return {
+            "raw_xml": clean_xml,
+            "summary": summary,
+            "issues": issues,
+            "recommendations": recommendations,
+        }
+        
+    except ET.ParseError as e:
+        logger.error(f"Failed to parse final LLM output: {e}", exc_info=True)
+        return {
+            "raw_xml": raw_response,
+            "error": "Failed to parse final LLM output."
+        }
+
+def get_formatting_rules() -> str:
+    """
+    Load the formatting rules from the markdown file.
+    """
+    with open(settings.formatting_rules_path, "r") as f:
+        return f.read()

modules/report_generator.py

@@ -0,0 +1,72 @@
+import logging
+from typing import Dict, Any
+from fpdf import FPDF
+import xml.etree.ElementTree as ET
+
+logger = logging.getLogger(__name__)
+
+def generate_report(analysis_results: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Generate a review report from the LLM's analysis results.
+    """
+    report = {
+        "summary": {},
+        "issues": [],
+        "recommendations": [],
+        "pdf_content": b""
+    }
+    
+    # Parse the XML output
+    raw_xml = analysis_results.get("raw_xml", "").strip()
+    if not raw_xml:
+        logger.error("Received empty or missing XML for report generation.")
+        return report
+
+    try:
+        root = ET.fromstring(raw_xml)
+        
+        # Extract summary
+        summary_node = root.find("summary")
+        if summary_node is not None:
+            report["summary"] = {
+                "overall_assessment": summary_node.findtext("overall_assessment", "N/A"),
+                "total_issues": summary_node.findtext("total_issues", "N/A"),
+                "critical_issues": summary_node.findtext("critical_issues", "N/A"),
+                "warning_issues": summary_node.findtext("warning_issues", "N/A"),
+            }
+            
+        # Extract issues
+        for issue_node in root.findall(".//issue"):
+            issue = {
+                "severity": issue_node.get("severity"),
+                "message": issue_node.findtext("message"),
+                "location": issue_node.findtext("location"),
+                "suggestion": issue_node.findtext("suggestion")
+            }
+            report["issues"].append(issue)
+            
+        # Extract recommendations
+        for rec_node in root.findall(".//recommendation"):
+            report["recommendations"].append(rec_node.text)
+            
+    except ET.ParseError as e:
+        logger.error(f"Failed to parse XML for report generation: {e}", exc_info=True)
+        # Handle XML parsing errors
+        pass
+        
+    # Generate PDF report
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_font("Arial", size=12)
+    
+    pdf.cell(200, 10, txt="Dissertation Review Report", ln=True, align="C")
+    
+    # TODO: Add more details to the PDF report
+    
+    report["pdf_content"] = pdf.output(dest='S').encode('latin-1')
+    
+    return report
+
+if __name__ == "__main__":
+    # This module is intended to be imported, not run directly.
+    pass

requirements.txt

@@ -0,0 +1,10 @@
+streamlit
+pydantic
+python-dotenv
+PyPDF2
+python-docx
+pdf2image
+pytesseract
+openai
+guidance
+fpdf

rules/formatting_rules.md

@@ -0,0 +1,98 @@
+# Graduate Center Dissertation Formatting Rules
+
+## Page Sequence
+Adhere to the following page sequence when preparing your manuscript. Note that bibliographic references should be the last section of the document, appearing after all appendices, glossaries, illustrations, or other back matter.
+
+1.  **Title page** (no pagination appears)*
+2.  **Copyright page**
+3.  **Approval page**
+4.  **Abstract**
+5.  **Preface, Foreword, and/or Acknowledgments** (optional)
+6.  **Table of Contents** (required)
+7.  **Lists of tables, illustrations, charts, figures, diagrams** (if applicable)
+8.  **Digital Manifest** (required for all digital projects)
+9.  **A Note on Technical Specifications** (required for all digital projects)
+10. **Body of Text** (begins with Arabic numeral 1)
+11. **Appendix or Appendices** (including Data Dictionary, if applicable)
+12. **Bibliography / References**
+13. **Autobiographical Statement** (optional)
+
+* use the degree year regardless of deposit date (February 2025 grads should have 2025 on their title page even if the deposit is in 2024)
+
+## Text Format Guidelines
+
+### Abstracts
+- There is no word limit for abstracts.
+- For digital projects, abstracts should describe the project scope and include relevant URLs for associated elements such as videos, websites, or code repositories (e.g., GitHub link); if applicable, describe what data has been collected.
+- Abstracts will be published in the CUNY Academic Works repository and ProQuest (if applicable) with author, title, and descriptive information, even if the work is embargoed.
+- An abstract in English is required, even if the text is in a language other than English.
+
+### Approval Page
+- The full title, author, manuscript statement, and month/year that the manuscript was approved are included on this page.
+- The approval page lists the primary advisor(s), executive officer or program director, and supervisory committee (if applicable) for the work being submitted.
+
+### Color
+- PDF and print reproductions may include color, and ProQuest reproductions will include any color submitted.
+
+### Data Dictionary (if applicable)
+- For projects that involve code or datasets, a Data Dictionary or equivalent must be included.
+- A Data Dictionary is typically located in the Appendix or in a separate file, and should be formatted according to your disciplinary conventions.
+- If it is submitted as a separate file, include the file name and format in the Digital Manifest.
+- Content could detail significant variables and critical functions.
+
+### Digital Manifest (Required for Digital Projects)
+- All dissertations, theses, and capstone projects that contain digital projects must include a “Digital Manifest” in the preliminary pages.
+- Formatted like a Table of Contents, this section provides a master list of all the components—print and digital—that constitute the project.
+- For each component, indicate its file type, a brief description, and URL, if applicable.
+
+### A Note on Technical Specifications (Required for Digital Projects)
+- All dissertations, theses, and capstone projects that contain digital projects must include a “Note on Technical Specifications” in the preliminary pages.
+- This section provides a high-level overview of the project’s components and technical specifications, analogous to a “readme” file.
+- Include information about components housed outside of the library deposit, such as GitHub repositories, and where to find the latest version of materials.
+
+### File Formats
+- ProQuest requires Adobe PDF (not Word) for text.
+- Rather than embedding audio and video files in the PDF body of a work, submit as supplemental files.
+
+### Font
+- Any legible TruType type 1 font is accepted (except script, italic, or ornamental fonts) if equivalent in scale to Arial (10 pt) or Times New Roman (12 pt).
+- Acceptable fonts and sizes for print and web include: Arial (10 pt), Courier New (10 pt), Georgia (11 pt), Times New Roman (12 pt), Trebuchet MS (10 pt), Verdana (10 pt).
+
+### Line-spacing
+- Double-space abstract, dedication, acknowledgements, table of contents, and body of the manuscript.
+- Follow your disciplinary style manual for single- or double-spacing block quotes, captions, items in tables, lists, graphs, charts.
+- Single-space footnotes/endnotes.
+
+### Lists of Contents
+- A table of contents is required.
+- If illustrations, charts, diagrams, figures or other tables appear in the work, a list of each named element, with corresponding pagination, is required.
+
+### Margins
+- left: 1”; right: 1″; top and bottom: 1″ for all text (except page numbers and headers/footers) and figures, footnotes/endnotes, and images
+
+### Page numbers
+- must appear at least ¾” from any edge of page
+
+### Pagination
+- Pages preliminary to the body of the text must be numbered with lowercase Roman numerals.
+- Do not number the title page but count it in the preliminary pagination.
+- The body of the text is numbered with Arabic numerals beginning with the first page of text and including illustrations, appendix, and bibliography.
+- Except for the title page, all pages must be numbered.
+- The numerals may appear in any location on the page (bottom middle, bottom right, upper right), but must be consistent throughout the work.
+
+### Quotations
+- Consult copyright fair use guidelines.
+- Include permission letters for use of copyrighted materials that exceeds fair use (photographs, charts, tables, etc.).
+- Submit copyright permission letters as supplemental files as part of your online submission.
+
+### References / Bibliography
+- In your references section, include the platforms, software libraries, and code used in your project. These can be separated from other bibliographic citations included in your manuscript if desired.
+
+### Style and Style Manuals
+- Use the style manual for your discipline except when in conflict with these instructions.
+- Consult dissertation advisors as necessary.
+
+### Title Page
+- The title page must include the full dissertation title, the complete name of the author, the dissertation statement, and the year of the degree.
+- Use words to spell out titles including formulas, symbols, superscripts, subscripts, and Greek letters.
+- While prohibited from the title, symbols may be used throughout the text.

startup_dissistant.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+# Startup script for Dissistant
+# This script starts the Streamlit service and exposes it via Tailscale Serve
+
+# Exit on error
+set -e
+
+# --- Configuration for Streamlit App ---
+STREAMLIT_APP_FILE="app.py"
+STREAMLIT_PORT="8502" 
+STREAMLIT_PID_FILE="dissistant.pid"
+STREAMLIT_LOG_FILE="dissistant.log"
+# --- End Configuration ---
+
+# Check if UV is installed
+if ! command -v uv &> /dev/null; then
+    echo "Error: UV is not installed. Please install UV first."
+    echo "You can install UV with: pip install uv"
+    exit 1
+fi
+
+# Create virtual environment if it doesn't exist
+if [ ! -d ".venv" ]; then
+    echo "Creating virtual environment..."
+    uv venv
+fi
+
+# Activate virtual environment
+echo "Activating virtual environment..."
+source .venv/bin/activate
+
+# Install dependencies
+echo "Installing dependencies..."
+uv pip install -r requirements.txt
+
+# Kill any existing instances of the Streamlit app
+echo "Stopping any existing instances of the Streamlit app..."
+if [ -f "$STREAMLIT_PID_FILE" ]; then
+    OLD_STREAMLIT_PID=$(cat $STREAMLIT_PID_FILE)
+    if ps -p $OLD_STREAMLIT_PID > /dev/null; then
+        kill $OLD_STREAMLIT_PID
+        echo "Killed existing Streamlit app process with PID $OLD_STREAMLIT_PID"
+        sleep 1 # Give it time to shut down
+    else
+        echo "No running Streamlit app process found with PID $OLD_STREAMLIT_PID"
+    fi
+fi
+# Also try to kill any other streamlit processes for this specific app file and port
+pkill -f "streamlit run $STREAMLIT_APP_FILE --server.port $STREAMLIT_PORT" || true
+sleep 1
+
+# Start the Streamlit app
+echo "Starting Streamlit app on port $STREAMLIT_PORT..."
+nohup streamlit run $STREAMLIT_APP_FILE --server.port $STREAMLIT_PORT --server.headless true > $STREAMLIT_LOG_FILE 2>&1 &
+echo $! > $STREAMLIT_PID_FILE
+
+# Check if the Streamlit service started successfully
+sleep 3 # Give Streamlit a bit more time to start
+if ! nc -z localhost $STREAMLIT_PORT; then
+    echo "Error: Failed to start Streamlit app on port $STREAMLIT_PORT."
+    cat $STREAMLIT_LOG_FILE # Output log file for debugging
+    exit 1
+else
+    echo "Streamlit app started successfully on port $STREAMLIT_PORT."
+fi
+
+# Check if Tailscale is installed
+if ! command -v tailscale &> /dev/null; then
+    echo "Warning: Tailscale is not installed. The app will only be available locally."
+    echo "Install Tailscale to expose the service over your tailnet."
+else
+    # Expose the service via Tailscale Serve
+    echo "Exposing Streamlit app via Tailscale Serve on port $STREAMLIT_PORT..."
+    echo "Setting up Funnel on port 10000..."
+    tailscale funnel --https=10000 --bg localhost:$STREAMLIT_PORT
+    
+    # Get the Tailscale hostname
+    HOSTNAME=$(tailscale status --json | jq -r '.Self.DNSName')
+    if [ -n "$HOSTNAME" ]; then
+        echo "App may be available at a Tailscale URL. Check 'tailscale status' for details."
+        echo "If using a funnel, it might be https://$HOSTNAME/"
+    else
+        echo "App is exposed via Tailscale Serve, but couldn't determine the primary hostname."
+        echo "Check 'tailscale status' for details."
+    fi
+fi
+
+echo "Dissistant is now running!"
+echo "Local URL: http://localhost:$STREAMLIT_PORT"
+echo "Log file: $STREAMLIT_LOG_FILE"
+echo "PID file: $STREAMLIT_PID_FILE"
+echo ""
+echo "If Tailscale is active, the app should be accessible via a Tailscale funnel URL."

utils/llm_utils.py

@@ -0,0 +1,23 @@
+import logging
+import httpx
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+logger = logging.getLogger(__name__)
+
+RETRYABLE_EXCEPTIONS = (
+    httpx.TimeoutException,
+    httpx.NetworkError,
+)
+
+@retry(
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=4, max=10),
+    retry=retry_if_exception_type(RETRYABLE_EXCEPTIONS),
+    before_sleep=lambda retry_state: logger.info(f"Retrying LLM call due to {retry_state.outcome.exception()}, attempt {retry_state.attempt_number + 1}...")
+)
+def call_llm_with_retry(llm, program):
+    """
+    Executes a guidance program with a given LLM, with retry logic.
+    The program is called with the llm, i.e., program(llm).
+    """
+    return program(llm)