:3

Dockerfile

@@ -1,13 +1,30 @@
-FROM python:3.12
+# Dockerfile for Weather Assistant Demo
+# This file configures how the application will run on Hugging Face Spaces
 
-WORKDIR /code
+# Start with Python 3.12 as our base image
+# This gives us a clean Python environment to work with
+FROM python:3.12
 
-COPY ./requirements.txt /code/requirements.txt
+# Install UV package manager
+# UV is a fast, reliable Python package installer written in Rust
+# It's much faster than pip for installing dependencies
+RUN pip install uv
 
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
+# Copy all files from our project into the container
+# This includes app.py, pyproject.toml, and other necessary files
 COPY . .
 
+# Use UV to install all dependencies specified in pyproject.toml
+# This ensures we have the same packages as in local development
+RUN uv sync
+
+# Configure the container to listen on port 7860
+# This is the default port that Hugging Face Spaces expects
 EXPOSE 7860
 
-CMD ["shiny", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]
+# Command to run when the container starts
+# This launches the Shiny app with specific host and port settings
+# - host 0.0.0.0 allows connections from outside the container
+# - port 7860 matches our EXPOSE setting above
+CMD ["/.venv/bin/shiny", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,21 +0,0 @@
----
-title: Group 13
-emoji: 🌍
-colorFrom: yellow
-colorTo: indigo
-sdk: docker
-pinned: false
-license: mit
-short_description: JOB
----
-
-This is a templated Space for [Shiny for Python](https://shiny.rstudio.com/py/). 
-
-
-To get started with a new app do the following:
-
-1) Install Shiny with `pip install shiny`
-2) Create a new app with `shiny create`
-3) Then run the app with `shiny run --reload`
-
-To learn more about this framework please see the [Documentation](https://shiny.rstudio.com/py/docs/overview.html).

app.py

@@ -1,162 +1,89 @@
-import faicons as fa
-import plotly.express as px
-
-# Load data and compute static values
-from shared import app_dir, tips
-from shinywidgets import render_plotly
-
-from shiny import reactive, render
-from shiny.express import input, ui
-
-bill_rng = (min(tips.total_bill), max(tips.total_bill))
-
-# Add page title and sidebar
-ui.page_opts(title="Restaurant tipping", fillable=True)
-
-with ui.sidebar(open="desktop"):
-    ui.input_slider(
-        "total_bill",
-        "Bill amount",
-        min=bill_rng[0],
-        max=bill_rng[1],
-        value=bill_rng,
-        pre="$",
-    )
-    ui.input_checkbox_group(
-        "time",
-        "Food service",
-        ["Lunch", "Dinner"],
-        selected=["Lunch", "Dinner"],
-        inline=True,
+from shiny import App
+from shiny.ui import page_navbar
+from shiny import ui
+import os
+
+from ui import (
+    home,
+    interview_scheduler,
+    candidate_profile,
+    correlation_analysis,
+    chart_generation,
+    job_creation,
+    document_creation  # 👈 NEW
+)
+
+from server import (
+    home as home_srv,
+    interview_scheduler as interview_scheduler_srv,
+    candidate_profile as candidate_profile_srv,
+    correlation_analysis as correlation_analysis_srv,
+    job_creation as job_creation_srv,
+    plot_generation as plot_generation_srv,
+    document_creation as document_creation_srv  # 👈 NEW
+)
+
+ui = ui.page_fluid(
+    # HEAD TAGS (global styles/fonts/scripts)
+    ui.tags.head(
+        ui.tags.link(
+            rel="stylesheet",
+            href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600&display=swap"
+        ),
+        ui.tags.link(
+            rel="stylesheet",
+            href="/static/custom.css"
+        ),
+        ui.tags.script(
+            """
+            document.addEventListener("DOMContentLoaded", function () {
+                const navLinks = document.querySelectorAll('.nav-link');
+                navLinks.forEach(link => {
+                    link.addEventListener('click', function (e) {
+                        // Delay default behavior to allow fade-out
+                        const targetTab = this.getAttribute('data-bs-target');
+                        const current = document.querySelector('.tab-pane.active');
+                        if (current && targetTab && targetTab !== `#${current.id}`) {
+                            current.classList.remove('active');
+                            current.style.opacity = 0;
+
+                            setTimeout(() => {
+                                const next = document.querySelector(targetTab);
+                                if (next) {
+                                    next.classList.add('active');
+                                    next.style.opacity = 1;
+                                }
+                            }, 150); // Match fade-out time
+                            e.preventDefault();
+                        }
+                    });
+                });
+            });
+            """
+        )
+    ),
+
+    # MAIN NAVBAR
+    ui.page_navbar(
+        home.ui,
+        job_creation.app_ui,
+        candidate_profile.ui,
+        interview_scheduler.interview_scheduler_ui,
+        correlation_analysis.ui,
+        chart_generation.plot_ui,
+        document_creation.document_creation_ui,
+        title="AI Recruitment Hub"
     )
-    ui.input_action_button("reset", "Reset filter")
-
-# Add main content
-ICONS = {
-    "user": fa.icon_svg("user", "regular"),
-    "wallet": fa.icon_svg("wallet"),
-    "currency-dollar": fa.icon_svg("dollar-sign"),
-    "ellipsis": fa.icon_svg("ellipsis"),
-}
-
-with ui.layout_columns(fill=False):
-    with ui.value_box(showcase=ICONS["user"]):
-        "Total tippers"
-
-        @render.express
-        def total_tippers():
-            tips_data().shape[0]
-
-    with ui.value_box(showcase=ICONS["wallet"]):
-        "Average tip"
-
-        @render.express
-        def average_tip():
-            d = tips_data()
-            if d.shape[0] > 0:
-                perc = d.tip / d.total_bill
-                f"{perc.mean():.1%}"
-
-    with ui.value_box(showcase=ICONS["currency-dollar"]):
-        "Average bill"
-
-        @render.express
-        def average_bill():
-            d = tips_data()
-            if d.shape[0] > 0:
-                bill = d.total_bill.mean()
-                f"${bill:.2f}"
-
-
-with ui.layout_columns(col_widths=[6, 6, 12]):
-    with ui.card(full_screen=True):
-        ui.card_header("Tips data")
-
-        @render.data_frame
-        def table():
-            return render.DataGrid(tips_data())
-
-    with ui.card(full_screen=True):
-        with ui.card_header(class_="d-flex justify-content-between align-items-center"):
-            "Total bill vs tip"
-            with ui.popover(title="Add a color variable", placement="top"):
-                ICONS["ellipsis"]
-                ui.input_radio_buttons(
-                    "scatter_color",
-                    None,
-                    ["none", "sex", "smoker", "day", "time"],
-                    inline=True,
-                )
-
-        @render_plotly
-        def scatterplot():
-            color = input.scatter_color()
-            return px.scatter(
-                tips_data(),
-                x="total_bill",
-                y="tip",
-                color=None if color == "none" else color,
-                trendline="lowess",
-            )
-
-    with ui.card(full_screen=True):
-        with ui.card_header(class_="d-flex justify-content-between align-items-center"):
-            "Tip percentages"
-            with ui.popover(title="Add a color variable"):
-                ICONS["ellipsis"]
-                ui.input_radio_buttons(
-                    "tip_perc_y",
-                    "Split by:",
-                    ["sex", "smoker", "day", "time"],
-                    selected="day",
-                    inline=True,
-                )
-
-        @render_plotly
-        def tip_perc():
-            from ridgeplot import ridgeplot
-
-            dat = tips_data()
-            dat["percent"] = dat.tip / dat.total_bill
-            yvar = input.tip_perc_y()
-            uvals = dat[yvar].unique()
-
-            samples = [[dat.percent[dat[yvar] == val]] for val in uvals]
-
-            plt = ridgeplot(
-                samples=samples,
-                labels=uvals,
-                bandwidth=0.01,
-                colorscale="viridis",
-                colormode="row-index",
-            )
-
-            plt.update_layout(
-                legend=dict(
-                    orientation="h", yanchor="bottom", y=1.02, xanchor="center", x=0.5
-                )
-            )
-
-            return plt
-
-
-ui.include_css(app_dir / "styles.css")
-
-# --------------------------------------------------------
-# Reactive calculations and effects
-# --------------------------------------------------------
-
+)
 
-@reactive.calc
-def tips_data():
-    bill = input.total_bill()
-    idx1 = tips.total_bill.between(bill[0], bill[1])
-    idx2 = tips.time.isin(input.time())
-    return tips[idx1 & idx2]
 
+def server(input, output, session):
+    home_srv.server(input, output, session)
+    job_creation_srv.server(input, output, session)
+    candidate_profile_srv.server(input, output, session)
+    interview_scheduler_srv.server(input, output, session)
+    correlation_analysis_srv.server(input, output, session)
+    plot_generation_srv.server(input, output, session)
+    document_creation_srv.server(input, output, session)
 
-@reactive.effect
-@reactive.event(input.reset)
-def _():
-    ui.update_slider("total_bill", value=bill_rng)
-    ui.update_checkbox_group("time", selected=["Lunch", "Dinner"])
+app = App(ui, server, static_assets={'/static': os.path.join(os.path.dirname(__file__), "styles")})

code/context.py

@@ -0,0 +1,91 @@
+import json
+import os
+
+CONTEXT_PATH = "data/context.json"
+
+def init_context():
+    if not os.path.exists("data"):
+        os.makedirs("data")
+    if not os.path.exists(CONTEXT_PATH):
+        with open(CONTEXT_PATH, "w") as f:
+            json.dump({"jobs": {}, "candidates": {}, 'employees': {}}, f)
+
+def load_context():
+    with open(CONTEXT_PATH, "r") as f:
+        return json.load(f)
+
+def save_job_context(job_id, job_data):
+    init_context()
+    context = load_context()
+    context["jobs"][job_id] = job_data
+    with open(CONTEXT_PATH, "w") as f:
+        json.dump(context, f, indent=2)
+
+def save_candidate_context(candidate_id, candidate_data):
+    init_context()
+    context = load_context()
+    context["candidates"][candidate_id] = candidate_data
+    with open(CONTEXT_PATH, "w") as f:
+        json.dump(context, f, indent=2)
+
+def get_job_context(job_id):
+    context = load_context()
+    return context["jobs"].get(job_id, {})
+
+def get_candidate_context(candidate_id):
+    context = load_context()
+    return context["candidates"].get(candidate_id, {})
+
+def get_all_jobs():
+    return load_context()["jobs"]
+
+def get_all_candidates():
+    return load_context()["candidates"]
+
+def save_employee_context(employee_id, employee_data):
+    init_context()
+    context = load_context()
+    context["employees"][employee_id] = employee_data
+    with open(CONTEXT_PATH, "w") as f:
+        json.dump(context, f, indent=2)
+
+def get_employee_context(employee_id):
+    context = load_context()
+    return context["employees"].get(employee_id, {})
+
+def get_all_employees():
+    return load_context()["employees"]
+
+def clear_context():
+    """Forcefully clears all saved job and candidate data in the context file."""
+    if not os.path.exists("data"):
+        os.makedirs("data")
+    with open(CONTEXT_PATH, "w") as f:
+        json.dump({"jobs": {}, "candidates": {}, 'employees': {}}, f, indent=2)
+
+def save_team_summary(summary_text):
+    init_context()
+    context = load_context()
+    context["team_summary"] = summary_text
+    with open(CONTEXT_PATH, "w") as f:
+        json.dump(context, f, indent=2)
+
+def get_team_summary():
+    context = load_context()
+    return context.get("team_summary", "")
+
+def save_candidate_offer(candidate_id, offer_text):
+    init_context()
+    context = load_context()
+    candidate = context["candidates"].get(candidate_id, {})
+    if "onboarding_docs" not in candidate:
+        candidate["onboarding_docs"] = {}
+    candidate["onboarding_docs"]["offer_letter"] = offer_text
+    context["candidates"][candidate_id] = candidate
+    with open(CONTEXT_PATH, "w") as f:
+        json.dump(context, f, indent=2)
+
+def get_candidate_offer(candidate_id):
+    context = load_context()
+    return context["candidates"].get(candidate_id, {}).get("onboarding_docs", {}).get("offer_letter", "")
+

code/llm_connect.py

@@ -0,0 +1,237 @@
+import os
+import pyrsm as rsm
+import google.generativeai as genai
+import requests
+
+# from google.genai import types
+from typing import List
+
+
+def query_llama(
+    messages: List[dict],
+    model: str = "llama-3",
+    max_tokens: int = 4000,
+    temperature: int = 0.4,
+    api_key: str = "",
+) -> dict:
+    """
+    Send a query to the Llama API
+
+    Args:
+        messages (list): List of dictionaries containing message role and content pairs
+        model (str): The model to use. Defaults to "llama-3"
+        max_tokens (int, optional): Maximum number of tokens to generate. Defaults to 4000
+        temperature (int, optional): Controls randomness in the output. 0 is deterministic, higher values more random. Defaults to 0.4
+        api_key (str, optional): Authentication token for API access. Defaults to ""
+
+    Example:
+        messages = [
+            {"role": "system", "content": "You are a helpful assistant"},
+            {"role": "user", "content": "Hello!"}
+        ]
+        response = query_llama(messages, api_key="your-api-key")
+
+    Returns:
+        dict: The model's response
+    """
+    url = "https://traip13.tgptinf.ucsd.edu/v1/chat/completions"
+    if not api_key or len(api_key) == 0:
+        raise ValueError("LLAMA: API key is required")
+
+    headers = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
+    data = {
+        "messages": messages,
+        "model": model,
+        "max_tokens": max_tokens,
+        "temperature": temperature,  # Adjust temperature for randomness (0 for deterministic)
+        "stream": False,
+        "n": 1,
+    }
+
+    response = requests.post(url, headers=headers, json=data)
+    response.raise_for_status()  # Raise an exception for bad status codes
+
+    return response.json()
+
+
+def test_llama_connection(api_key: str, timeout: int = 20) -> bool:
+    """Test connection to Llama API with a basic request"""
+    import requests
+
+    url = "https://traip13.tgptinf.ucsd.edu/v1/chat/completions"
+    headers = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
+    data = {"messages": [], "model": "llama-3", "max_tokens": 1, "temperature": 0.4}
+
+    try:
+        response = requests.post(url, headers=headers, json=data, timeout=20)
+        print(f"Status code: {response.status_code}")
+        print(f"Response headers: {response.headers}")
+        try:
+            print(f"Response body: {response.json()}")
+        except Exception:
+            print(f"Response text: {response.text}")
+        if response.status_code == 401:
+            print("Authentication failed - check your API key")
+            return False
+        elif response.status_code == 404:
+            print("API endpoint not found")
+            return False
+        elif response.status_code == 200:
+            return True
+        else:
+            print(f"Unexpected status code: {response.status_code}")
+            return False
+    except requests.exceptions.Timeout:
+        print(f"Connection timed out after {timeout} seconds")
+        return False
+    except requests.exceptions.ConnectionError:
+        print("Could not connect to server")
+        return False
+
+
+def query_gemini(
+    messages: List[dict],
+    model: str = "gemini-2.0-flash",
+    max_tokens: int = 4000,
+    temperature: int = 0.4,
+    api_key: str = "",
+) -> dict:
+    """
+    Send a query to the Gemini API
+
+    Args:
+        messages (list): List of dictionaries containing message role and content pairs
+        model (str): The model to use. Defaults to "gemini-2.0-flash"
+        max_tokens (int, optional): Maximum number of tokens to generate. Defaults to 4000
+        temperature (int, optional): Controls randomness in the output. 0 is deterministic, higher values more random. Defaults to 0.4
+        api_key (str, optional): Authentication token for API access. Defaults to ""
+
+    Returns:
+        dict: The model's response
+    """
+
+    if not api_key or len(api_key) == 0:
+        raise ValueError("Gemini: API key is required")
+
+    # Convert OpenAI-style messages to Gemini format
+    system_message = [msg["content"] for msg in messages if msg["role"] == "system"]
+    user_messages = [msg["content"] for msg in messages if msg["role"] == "user"]
+
+    # Combine system message (if any) with the user message
+    prompt = ". ".join(system_message + user_messages)
+
+    genai.configure(api_key=api_key)
+
+    # Initialize the model
+    model = genai.GenerativeModel(model_name=model)
+
+    # Define the generation configuration using the specific class
+    generation_config_obj = genai.types.GenerationConfig(
+        temperature=temperature,
+        max_output_tokens=max_tokens,
+    )
+
+    # Generate content using the correct parameter name 'generation_config'
+    response = model.generate_content(
+        contents=prompt, generation_config=generation_config_obj
+    )
+
+    return response.text
+
+
+def get_response(
+    input: str | List[str],
+    template: callable,
+    role: str = "You are a helpful assistant.",
+    temperature: float = 0.4,
+    max_tokens: int = 4000,
+    md: bool = True,
+    llm: str = "llama",
+    model_name: str = None,
+):
+    """
+    Function to get a response from the LLama API
+    """
+    messages = [
+        {"role": "system", "content": role},
+        {
+            "role": "user",
+            "content": template(input),
+        },
+    ]
+
+    if llm == "llama":
+        response = query_llama(
+            messages=messages,
+            api_key=os.getenv("LLAMA_API_KEY"),
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )["choices"][0]["message"]["content"]
+    elif llm == "gemini":
+        response = query_gemini(
+            messages=messages,
+            api_key=os.getenv("GEMINI_API_KEY"),
+            temperature=temperature,
+            max_tokens=max_tokens,
+            model=model_name if model_name else 'gemini-2.0-flash'
+        )
+    else:
+        raise ValueError("LLM: Invalid LLM specified")
+
+    if md:
+        return rsm.md(response)
+    else:
+        return response
+
+
+if __name__ == "__main__":
+    from dotenv import load_dotenv
+
+    # Load environment variables
+    load_dotenv()
+
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Hi, how are you? What is your name?"},
+    ]
+
+    # Testing Llama connection
+    try:
+        print("\nTesting Llama connection ...")
+        test_llama_connection(api_key=os.getenv("LLAMA_API_KEY"))
+    except Exception as e:
+        print(f"Error: {e}")
+
+    # Testing Llama connection
+    try:
+        print("\nQuerying Llama ...")
+        response = query_llama(messages, api_key=os.getenv("LLAMA_API_KEY"))
+        print(response)
+    except Exception as e:
+        print(f"Error: {e}")
+
+    try:
+        print("\nQuerying Gemini ...")
+        response = query_gemini(messages, api_key=os.getenv("GEMINI_API_KEY"))
+        print(response)
+    except Exception as e:
+        print(f"Error: {e}")
+
+    try:
+        print("\nTesting get_response ...")
+
+        def template(input):
+            return f"""Evaluate the following statement for factual accuracy. If it's incorrect, provide the correct information:
+            Statement: {input}
+            Evaluation:"""
+
+        response = get_response(
+            "The capital of the Netherlands is Utrecht.",
+            template=template,
+            md=False,
+            llm="llama",
+        )
+        print(response)
+
+    except Exception as e:
+        print(f"Error: {e}")

server/candidate_profile.py

@@ -0,0 +1,381 @@
+import os
+import fitz
+import json
+import re
+from shiny import reactive, render, ui
+from context import get_candidate_context, save_candidate_context, get_team_summary, get_job_context, get_all_jobs, get_all_candidates
+from llm_connect import get_response
+import html
+import markdown
+
+
+RESUME_DIR = "../data/resumes"
+
+def extract_text_from_pdf(filename):
+    path = os.path.join(RESUME_DIR, filename) + '.pdf'
+    if not os.path.exists(path):
+        print(f"❌ Resume not found: {path}")
+        return None, None
+    try:
+        doc = fitz.open(path)
+        return "\n".join([page.get_text() for page in doc]), path
+    except Exception as e:
+        print("❌ PDF error:", e)
+        return None, None
+
+def parse_resume_with_llm(resume_text, job_description_text, team_profiles, team_summary):
+    prompt = (
+        f"You are evaluating a candidate for the following job posting:\n\n"
+        f"{job_description_text}\n\n"
+        f"Here is the candidate's resume:\n\n"
+        f"{resume_text}\n\n"
+        f"Here are the profiles of the current team members:\n\n{team_profiles}\n\n"
+        f"Here is the team summary:\n\n{team_summary}\n\n"
+        "Extract the following fields into a valid JSON object:\n"
+        "- Name\n"
+        "- Email\n"
+        "- Years of Experience\n"
+        "- Key Skills (as a list)\n"
+        "- Llama Score (judge the candidate's overall fit for the job on a scale of 1–10)\n\n"
+        "⚠️ Return ONLY a single valid JSON object and nothing else.\n"
+    )
+
+    response_text = get_response(
+        input=prompt,
+        template=lambda x: x,
+        llm="llama",
+        md=False,
+        temperature=0.0,
+        max_tokens=700,
+    )
+
+    response_text = response_text.strip().replace("```json", "").replace("```", "").strip()
+    match = re.search(r'\{\s*".+?"\s*:.+?\}', response_text, re.DOTALL)
+    if not match:
+        raise ValueError("No valid JSON object found in LLM response.")
+    return json.loads(match.group(0))
+
+def review_llama_score(resume_text, job_description_text, score, team_profiles, team_summary):
+    prompt = (
+        f"You are evaluating a candidate for the following posting:\n\n"
+        f"{job_description_text}\n\n"
+        f"Resume:\n{resume_text}\n\n"
+        f"Team Profiles:\n{team_profiles}\n\n"
+        f"Team Summary:\n{team_summary}\n\n"
+        f"Llama gave this candidate a score of {score}/10.\n"
+        "What is your score (1–10)? Only return the number."
+    )
+
+    return get_response(
+        input=prompt,
+        template=lambda x: x,
+        llm="gemini",
+        md=False,
+        temperature=0.0,
+        max_tokens=10,
+        model_name ='gemini-2.0-flash-lite'
+    ).strip()
+
+def summarize_entire_resume(resume_text, job_description_text, score, team_profiles, team_summary):
+    prompt = (
+        f"Job Description:\n{job_description_text}\n\n"
+        f"Resume:\n{resume_text}\n\n"
+        f"Team Profiles:\n{team_profiles}\n\n"
+        f"Team Summary:\n{team_summary}\n\n"
+        f"The candidate received a score of {score}/10.\n"
+        "Write a detailed, honest summary of this candidate's qualifications and fit."
+    )
+
+    return get_response(
+        input=prompt,
+        template=lambda x: x,
+        llm="llama",
+        md=False,
+        temperature=0.7,
+        max_tokens=500
+    ).strip()
+
+def review_llama_summary(resume_text, job_description_text, score, llama_review, team_profiles, team_summary):
+    prompt = (
+        f"You are reviewing this Llama summary for a candidate:\n\n"
+        f"Job Description:\n{job_description_text}\n\n"
+        f"Resume:\n{resume_text}\n\n"
+        f"Llama Summary:\n{llama_review}\n\n"
+        f"Team Profiles:\n{team_profiles}\n\n"
+        f"Team Summary:\n{team_summary}\n\n"
+        f"Llama scored this candidate {score}/10.\n"
+        "Write your own short evaluation and state if you agree or disagree with Llama’s score."
+    )
+
+    return get_response(
+        input=prompt,
+        template=lambda x: x,
+        llm="gemini",
+        md=False,
+        temperature=0.7,
+        max_tokens=500
+    ).strip()
+
+def server(input, output, session):
+
+
+    @reactive.effect
+    def _populate_job_dropdown():
+        jobs = get_all_jobs()
+        job_choices = {
+            k: f"{v.get('title', 'Untitled')} ({k[:8]})"
+            for k, v in jobs.items()
+        }
+        print(job_choices)
+        ui.update_select("job_dropdown_for_doc", choices=job_choices)
+
+
+    @reactive.effect
+    def _populate_candidate_dropdown():
+        job_id = input.job_dropdown_for_doc()
+        print("📎 selected job_id:", job_id)
+
+        if not job_id:
+            ui.update_select("candidate_dropdown_for_doc", choices={"⬅️ Select a job first": ""})
+            return
+
+        candidates = get_all_candidates()
+
+        filtered = {
+            cid: f"{v.get('Name', cid)} ({v.get('Resume File', 'N/A')})"
+            for cid, v in candidates.items()
+            if v.get("job_id") == job_id and v.get("Resume File")
+        }
+
+        print(f"✅ Found {len(filtered)} candidates for job {job_id}")
+
+        if filtered:
+            ui.update_select("candidate_dropdown_for_doc", choices=filtered)
+        else:
+            ui.update_select("candidate_dropdown_for_doc", choices={"❌ No matching resumes": ""})
+
+
+
+
+    @output
+    @render.ui
+    def summary():
+        input.show_gemini()             # ✅ force reactive trigger
+        input.job_dropdown_doc()
+        input.candidate_dropdown_doc()
+
+        filename = input.candidate_dropdown_doc()
+        job_id = input.job_dropdown_doc()  # 🔧 ADD THIS LINE
+        use_gemini = input.show_gemini()
+
+        if not filename or not job_id:
+            return "Please select both resume and job ID."
+
+        job_context = get_job_context(job_id)  # ✅ This now works
+        job_description_text = job_context.get("job_description", "No job description available.")
+        team_profiles = job_context.get("team_profiles", "No team profile available.")
+        team_summary = get_team_summary()
+
+        candidate_id = os.path.splitext(filename)[0]
+        ctx = get_candidate_context(candidate_id)
+
+        # ✅ If already evaluated for this job, return cached summary
+        if ctx.get("job_id") == job_id and "Llama Summary" in ctx:
+            use_gemini = input.show_gemini()
+            print(f"🧪 Cached summary found for {candidate_id} / job {job_id} | Gemini: {use_gemini}")
+
+            raw = ctx.get("Gemini Summary" if use_gemini else "Llama Summary", "No summary available")
+            rendered = markdown.markdown(raw.strip())
+
+            return ui.HTML(
+                f"""
+                <div style="
+                    font-family: 'Inter', 'Segoe UI', 'Helvetica Neue', sans-serif;
+                    font-size: 1rem;
+                    line-height: 1.6;
+                    white-space: normal;
+                    word-wrap: break-word;
+                    max-width: 900px;
+                ">
+                    {rendered}
+                </div>
+                """
+            )
+
+        # ✅ Run full pipeline
+        resume_text, resume_path = extract_text_from_pdf(filename)
+        if not resume_text:
+            return "Failed to extract resume."
+
+        try:
+            parsed = parse_resume_with_llm(resume_text, job_description_text, team_profiles, team_summary)
+        except Exception as e:
+            return f"❌ LLM field extraction failed: {e}"
+
+        llama_score = parsed["Llama Score"]
+        gemini_score = review_llama_score(resume_text, job_description_text, llama_score, team_profiles, team_summary)
+        try:
+            gemini_score = int(gemini_score)
+        except:
+            gemini_score = None
+
+        avg_score = (
+            (llama_score + gemini_score) / 2
+            if isinstance(llama_score, int) and isinstance(gemini_score, int)
+            else "N/A"
+        )
+
+        llama_summary = summarize_entire_resume(resume_text, job_description_text, llama_score, team_profiles, team_summary)
+        gemini_review = review_llama_summary(resume_text, job_description_text, llama_score, llama_summary, team_profiles, team_summary)
+
+        # ✅ Save new result
+        ctx.update({
+            "job_id": job_id,
+            "Resume File": filename,
+            "Name": parsed.get("Name"),
+            "Email": parsed.get("Email"),
+            "Years of Experience": parsed.get("Years of Experience"),
+            "Key Skills": parsed.get("Key Skills", []),
+            "Llama Score": llama_score,
+            "Gemini Score": gemini_score,
+            "avg_score": avg_score,
+            "Llama Summary": llama_summary,
+            "Gemini Summary": gemini_review
+        })
+
+        save_candidate_context(candidate_id, ctx)
+
+        print(use_gemini)
+        summary_text = gemini_review if use_gemini else llama_summary
+        rendered = markdown.markdown(summary_text)
+
+
+        return ui.HTML(f"""
+            <div style="
+                font-family: 'Inter', 'Segoe UI', 'Helvetica Neue', sans-serif;
+                font-size: 1rem;
+                line-height: 1.6;
+                white-space: normal;
+                word-wrap: break-word;
+                max-width: 900px;
+            ">
+                {rendered}
+            </div>
+        """)
+
+    
+    @output
+    @render.ui
+    def score():
+        filename = input.candidate_dropdown_doc()
+        job_id = input.job_dropdown_doc()
+
+        if not filename or not job_id:
+            return ui.HTML("<p style='color: #888;'>Select a resume and job to view score.</p>")
+
+        candidate_id = os.path.splitext(filename)[0]
+        ctx = get_candidate_context(candidate_id)
+
+        if ctx.get("job_id") == job_id and "avg_score" in ctx:
+            score = ctx["avg_score"]
+
+            # Choose a color based on the score
+            if isinstance(score, (int, float)):
+                color = (
+                    "green" if score >= 8 else
+                    "orange" if score >= 5 else
+                    "red"
+                )
+            else:
+                color = "gray"
+
+            return ui.HTML(f"""
+                <div style="
+                    background-color: {color};
+                    color: white;
+                    font-weight: bold;
+                    font-size: 1.1rem;
+                    padding: 0.6rem 1.2rem;
+                    border-radius: 8px;
+                    display: inline-block;
+                ">
+                    Average Score: {score}
+                </div>
+            """)
+
+        return ui.HTML("<p style='color: #888;'>Score not available. Generate profile first.</p>")
+
+    
+    @output
+    @render.text
+    def candidate_note_ui():
+        filename = input.candidate_dropdown_doc()
+        job_id = input.job_dropdown_doc()
+        if not filename or not job_id:
+            return ui.input_text_area("candidate_note", "Add a note:", rows=3)
+
+        candidate_id = os.path.splitext(filename)[0]
+        ctx = get_candidate_context(candidate_id)
+        note = ctx.get("Note", "") if ctx.get("job_id") == job_id else ""
+        return ui.input_text_area("candidate_note", "Add a note:", value=note, rows=3)
+
+    @output
+    @render.ui
+    def candidate_tags_ui():
+        filename = input.candidate_dropdown_doc()
+        job_id = input.job_dropdown_doc()
+        if not filename or not job_id:
+            return ui.input_text("candidate_tags", "Tags (comma-separated):")
+
+        candidate_id = os.path.splitext(filename)[0]
+        ctx = get_candidate_context(candidate_id)
+        tags = ", ".join(ctx.get("Tags", [])) if ctx.get("job_id") == job_id else ""
+        return ui.input_text("candidate_tags", "Tags (comma-separated):", value=tags)
+
+
+    @output
+    @render.text
+    def note_preview():
+        filename = input.candidate_dropdown_doc()
+        job_id = input.job_dropdown_doc()
+        if not filename or not job_id:
+            return ""
+
+        candidate_id = os.path.splitext(filename)[0]
+        ctx = get_candidate_context(candidate_id)
+
+        if ctx.get("job_id") != job_id:
+            return ""
+
+        note = ctx.get("Note", "[No note]")
+        tags = ctx.get("Tags", [])
+        return f"📝 Note:\n{note}\n\n🏷️ Tags: {', '.join(tags)}"
+    
+    @output
+    @render.text
+    @reactive.event(input.save_note_tags)
+    def note_tag_status():
+        filename = input.candidate_dropdown_doc()
+        job_id = input.job_dropdown_doc()
+        if not filename or not job_id:
+            return "❌ Please select both a resume and a job ID."
+
+        candidate_id = os.path.splitext(filename)[0]
+        ctx = get_candidate_context(candidate_id)
+
+        # Only update if job_id matches
+        if ctx.get("job_id") != job_id:
+            return "⚠️ Cannot save notes — no profile generated for this candidate/job combination."
+
+        # Get input
+        note = input.candidate_note().strip()
+        tags_raw = input.candidate_tags()
+        tags = [tag.strip() for tag in tags_raw.split(",") if tag.strip()]
+
+        # Save to context
+        ctx["Note"] = note
+        ctx["Tags"] = tags
+        save_candidate_context(candidate_id, ctx)
+
+        return "✅ Note and tags saved."
+

server/correlation_analysis.py

@@ -0,0 +1,190 @@
+import os
+import json
+import pandas as pd
+import numpy as np
+import ast
+from dotenv import load_dotenv
+from shiny import reactive, render, ui
+import google.generativeai as genai
+from google.generativeai.types import FunctionDeclaration, Tool
+from google.api_core.exceptions import ResourceExhausted
+import markdown
+
+from context import get_all_candidates, get_all_jobs
+
+load_dotenv()
+
+# === Tool Function ===
+def correlate_columns(df: pd.DataFrame, col1: str, col2: str) -> dict:
+    if col1 not in df.columns or col2 not in df.columns:
+        return {"error": f"One or both columns not found: '{col1}', '{col2}'"}
+    if col1 == col2:
+        return {"error": "Cannot correlate a column with itself."}
+    subset = df[[col1, col2]].dropna()
+    for col in [col1, col2]:
+        if subset[col].dtype == "object" or pd.api.types.is_categorical_dtype(subset[col]):
+            subset[col], _ = pd.factorize(subset[col])
+    try:
+        return subset.corr(method="pearson").to_dict()
+    except Exception as e:
+        return {"error": str(e)}
+
+# === Gemini Tool Setup ===
+correlation_func_schema = FunctionDeclaration(
+    name="correlate_columns",
+    description="Calculate the Pearson correlation between two candidate variables.",
+    parameters={
+        "type": "object",
+        "properties": {
+            "col1": {"type": "string", "description": "First column"},
+            "col2": {"type": "string", "description": "Second column"}
+        },
+        "required": ["col1", "col2"]
+    }
+)
+correlation_tool = Tool(function_declarations=[correlation_func_schema])
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+model = genai.GenerativeModel("gemini-2.0-flash", tools=[correlation_tool])
+
+# === Server ===
+def server(input, output, session):
+    print("✅ Loaded context-aware Gemini correlation server")
+
+    last_corr = reactive.Value(None)
+    last_cols = reactive.Value(("", ""))
+    chat_status = reactive.Value("")
+
+
+    @reactive.effect
+    def _populate_job_ids():
+        raw_candidates = get_all_candidates()
+        job_ids_used = {c.get("job_id") for c in raw_candidates.values() if "job_id" in c}
+
+        all_jobs = get_all_jobs()
+
+        # Build label: value mapping
+        job_choices = {
+            job_id: f"{job_data.get('title', 'Untitled')} ({job_id[:8]})"
+            for job_id, job_data in all_jobs.items()
+            if job_id in job_ids_used
+        }
+
+        print(f"📊 Populating job_id dropdown with {len(job_choices)} items")
+        ui.update_select("job_id", choices=job_choices)
+
+
+    @reactive.Calc
+    def candidates():
+        raw = get_all_candidates()
+        job_id = input.job_id()
+        if not job_id:
+            return pd.DataFrame()
+        df = pd.DataFrame([c for c in raw.values() if c.get("job_id") == job_id])
+        df["Years of Experience"] = pd.to_numeric(df["Years of Experience"], errors="coerce")
+        df["avg_score"] = pd.to_numeric(df["avg_score"], errors="coerce")
+        df["Key Skills"] = df["Key Skills"].apply(lambda x: ast.literal_eval(x) if isinstance(x, str) else x)
+        return df
+
+    @reactive.effect
+    def _populate_cols():
+        df = candidates()
+        if df.empty:
+            return
+        exclude = {
+            "Name", "Email", "Key Skills", "Candidate ID", "Application ID", "Resume File",
+            "Llama Summary", "Gemini Summary", "Note", "candidate_id", "job_id",
+            "application_date", "source"
+        }
+        cols = [col for col in df.columns if col not in exclude]
+        ui.update_select("col1", choices=cols)
+        ui.update_select("col2", choices=cols)
+
+    @output
+    @render.table
+    def candidate_table():
+        df = candidates()
+        return df.drop(columns=["Resume File", "Llama Summary", "Gemini Summary", "onboarding_docs", "job_id", "Candidate ID"], errors="ignore").head(10)
+
+    @output
+    @render.ui
+    def correlation_output():
+        if input.calc_corr() == 0:
+            return ui.p("⬇️ Select columns and click 'Calculate Correlation'.")
+        df = candidates()
+        col1 = input.col1()
+        col2 = input.col2()
+        if df.empty or not col1 or not col2:
+            return ui.p("⚠️ Please select a job and valid columns.")
+        result = correlate_columns(df, col1, col2)
+        if "error" in result:
+            return ui.p(f"❌ {result['error']}")
+        try:
+            corr_value = result[col1][col2]
+        except:
+            return ui.p("❌ Failed to extract correlation value.")
+
+        last_corr.set(corr_value)
+        last_cols.set((col1, col2))
+
+        prompt = (
+            f"The Pearson correlation between '{col1}' and '{col2}' is {corr_value:.4f}.\n\n"
+            f"Explain this for a recruiter: include statistical meaning, hiring implications, and limitations."
+        )
+        try:
+            chat = model.start_chat()
+            response = chat.send_message(prompt)
+            explanation = markdown.markdown(response.text.strip())
+        except Exception as e:
+            explanation = f"<b>⚠️ Gemini error:</b> {str(e)}"
+
+        return ui.HTML(f"""
+            <div><strong>{col1}</strong> vs <strong>{col2}</strong> correlation: <b>{corr_value:.4f}</b></div>
+            <hr><div><strong>LLM Explanation:</strong><br>{explanation}</div>
+        """)
+
+    @output
+    @render.text
+    def chat_status_ui():
+        return chat_status.get()
+
+    @output
+    @render.ui
+    @reactive.event(input.chat_send)
+    def chat_response():
+        user_msg = input.chat_input().strip()
+        col1, col2 = last_cols.get()
+        corr_value = last_corr.get()
+        df = candidates()
+
+        if not user_msg:
+            return ui.HTML("<i>⚠️ Please enter a follow-up question.</i>")
+        if df.empty:
+            return ui.HTML("<i>⚠️ No candidate data loaded.</i>")
+        if not col1 or corr_value is None:
+            return ui.HTML("<i>⚠️ Please run a correlation first.</i>")
+
+        chat_status.set("💬 Thinking...")
+
+        # Provide full data context for Gemini: 10 rows, all columns
+        cleaned_df = df.drop(columns=["Resume File", "Llama Summary", "Gemini Summary"], errors="ignore")
+        sample_json = json.dumps(cleaned_df.head(10).to_dict(orient="records"), indent=2)
+
+        prompt = (
+            f"You are helping a recruiter analyze candidate data.\n\n"
+            f"The last Pearson correlation was between '{col1}' and '{col2}' = {corr_value:.4f}.\n"
+            f"The user asked: \"{user_msg}\"\n\n"
+            f"Here is a preview of the first 10 rows of the dataset:\n{sample_json}\n\n"
+            f"Use both the correlation and sample data to respond helpfully."
+        )
+
+        try:
+            chat = model.start_chat()
+            response = chat.send_message(prompt)
+            explanation = markdown.markdown(response.text.strip())
+        except ResourceExhausted:
+            explanation = "<b>❌ Gemini quota exceeded. Try again soon.</b>"
+        except Exception as e:
+            explanation = f"<b>❌ Gemini error:</b> {str(e)}"
+
+        chat_status.set("")
+        return ui.HTML(explanation)

server/document_creation.py

@@ -0,0 +1,224 @@
+import os
+from shiny import reactive, render, ui
+from context import (
+    get_candidate_context,
+    get_job_context,
+    get_team_summary,
+    save_candidate_context,
+    get_all_jobs,
+    get_all_candidates
+)
+from llm_connect import get_response
+
+from fpdf import FPDF
+import markdown
+import io
+
+
+def draft_offer_letter(candidate_name, job_title, compensation, start_date, team_summary, job_description, hiring_manager_notes):
+    prompt = (
+        f"Candidate Name: {candidate_name}\n"
+        f"Job Title: {job_title}\n"
+        f"Compensation: {compensation}\n"
+        f"Start Date: {start_date}\n\n"
+        f"Job Description:\n{job_description}\n\n"
+        f"Team Summary:\n{team_summary}\n\n"
+        f"Hiring Manager Notes:\n{hiring_manager_notes}\n\n"
+        "Write a professional, clear, and positive offer letter for this candidate. "
+        "Include a summary of the role, compensation details, start date, and a warm welcome. "
+        "Avoid excessive legal language but maintain formality."
+    )
+
+    return get_response(
+        input=prompt,
+        template=lambda x: x,
+        llm="llama",
+        md=False,
+        temperature=0.5,
+        max_tokens=600
+    ).strip()
+
+
+def generate_full_contract(candidate_name, job_title, compensation, start_date, clauses, company_policies, legal_notes):
+    prompt = (
+        f"Candidate Name: {candidate_name}\n"
+        f"Job Title: {job_title}\n"
+        f"Compensation: {compensation}\n"
+        f"Start Date: {start_date}\n\n"
+        f"Clauses:\n{clauses}\n\n"
+        f"Company Policies:\n{company_policies}\n\n"
+        f"Legal Notes:\n{legal_notes}\n\n"
+        "Draft a complete employment contract using the information above. "
+        "Structure it with proper headings, include all clauses, and align with common HR compliance standards. "
+        "Use formal legal language where appropriate."
+    )
+
+    return get_response(
+        input=prompt,
+        template=lambda x: x,
+        llm="llama",
+        md=False,
+        temperature=0.4,
+        max_tokens=1200
+    ).strip()
+
+
+def server(input, output, session):
+    # === Update job dropdown from context ===
+    @reactive.effect
+    def _populate_job_dropdown():
+        jobs = get_all_jobs()
+        # value = job_id (UUID), label = title
+        job_choices = {
+            k: f"{v.get('title', 'Untitled')} ({k[:8]})"
+            for k, v in jobs.items()
+        }
+        ui.update_select("job_dropdown_doc", choices=job_choices)
+
+
+    # === Update candidate dropdown based on selected job ===
+    @reactive.effect
+    def _populate_candidate_dropdown():
+        job_id = input.job_dropdown_doc()
+        print("📎 selected job_id:", job_id)
+
+        if not job_id:
+            ui.update_select("candidate_dropdown_doc", choices={"⬅️ Select a job first": ""})
+            return
+
+        candidates = get_all_candidates()
+
+        filtered = {
+            cid: f"{v.get('Name', cid)} ({v.get('Resume File', 'N/A')})"
+            for cid, v in candidates.items()
+            if v.get("job_id") == job_id and v.get("Resume File")
+        }
+
+
+        print(f"✅ Found {len(filtered)} candidates for job {job_id}")
+
+        if filtered:
+            ui.update_select("candidate_dropdown_doc", choices=filtered)
+        else:
+            ui.update_select("candidate_dropdown_doc", choices={"❌ No matching resumes": ""})
+
+
+
+
+    # === Offer letter generation ===
+    @output
+    @render.text
+    @reactive.event(input.generate_offer)
+    def offer_letter_text():
+        candidate_id = input.candidate_dropdown_doc()
+        job_id = input.job_dropdown_doc()
+
+        print("📦 candidate_id:", candidate_id)
+        print("📦 job_id:", job_id)
+
+        if not candidate_id or not job_id:
+            return "❌ Select a resume and a job."
+
+        ctx = get_candidate_context(candidate_id)
+        job = get_job_context(job_id)
+
+        print("📁 ctx loaded:", bool(ctx))
+        print("📁 job loaded:", bool(job))
+
+        if not ctx or not job:
+            return "❌ Missing candidate or job context."
+
+        comp_override = input.override_compensation().strip()
+        start_override = input.override_start_date().strip()
+        notes_override = input.override_notes().strip()
+
+        offer = draft_offer_letter(
+            candidate_name=ctx.get("Name", "Candidate"),
+            job_title=job.get("title", "Unknown Role"),
+            compensation=comp_override or job.get("compensation", "TBD"),
+            start_date=start_override or job.get("start_date", "TBD"),
+            team_summary=get_team_summary(),
+            job_description=job.get("job_description", ""),
+            hiring_manager_notes=notes_override or job.get("notes", "")
+        )
+
+        ctx.setdefault("onboarding_docs", {})["offer_letter"] = offer
+        save_candidate_context(candidate_id, ctx)
+        return ui.HTML(f"<pre style='font-family: Georgia; font-size: 1rem'>{offer}</pre>")
+
+    # === Contract generation ===
+    @output
+    @render.text
+    @reactive.event(input.generate_contract)
+    def contract_text():
+        candidate_id = input.candidate_dropdown_doc()
+        job_id = input.job_dropdown_doc()
+
+        if not candidate_id or not job_id:
+            return "❌ Select a resume and a job."
+
+        ctx = get_candidate_context(candidate_id)
+        job = get_job_context(job_id)
+
+        if not ctx or not job:
+            return "❌ Missing candidate or job context."
+
+        comp_override = input.override_compensation().strip()
+        start_override = input.override_start_date().strip()
+
+        contract = generate_full_contract(
+            candidate_name=ctx.get("Name", "Candidate"),
+            job_title=job.get("title", "Unknown Role"),
+            compensation=comp_override or job.get("compensation", "TBD"),
+            start_date=start_override or job.get("start_date", "TBD"),
+            clauses=job.get("clauses", "Standard IP, termination, arbitration clauses."),
+            company_policies=job.get("policies", "All standard company HR policies apply."),
+            legal_notes=job.get("legal_notes", "Subject to U.S. labor law.")
+        )
+
+        ctx.setdefault("onboarding_docs", {})["contract"] = contract
+        save_candidate_context(candidate_id, ctx)
+        return ui.HTML(f"<pre style='font-family: Georgia; font-size: 1rem'>{contract}</pre>")
+
+    @output
+    @render.download(filename="Offer_Letter.pdf")
+    def download_offer():
+        candidate_id = input.candidate_dropdown_doc()
+        ctx = get_candidate_context(candidate_id)
+        offer = ctx.get("onboarding_docs", {}).get("offer_letter", "No offer letter found.")
+
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_auto_page_break(auto=True, margin=15)
+        pdf.set_font("Arial", size=12)
+
+        for line in offer.split("\n"):
+            pdf.multi_cell(0, 10, line)
+
+        pdf_bytes = io.BytesIO()
+        pdf_bytes.write(pdf.output(dest="S").encode("latin1"))
+        pdf_bytes.seek(0)
+        return pdf_bytes
+
+
+    @output
+    @render.download(filename="Contract.pdf")
+    def download_contract():
+        candidate_id = input.candidate_dropdown_doc()
+        ctx = get_candidate_context(candidate_id)
+        contract = ctx.get("onboarding_docs", {}).get("contract", "No contract found.")
+
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_auto_page_break(auto=True, margin=15)
+        pdf.set_font("Arial", size=12)
+
+        for line in contract.split("\n"):
+            pdf.multi_cell(0, 10, line)
+
+        pdf_bytes = io.BytesIO()
+        pdf_bytes.write(pdf.output(dest="S").encode("latin1"))
+        pdf_bytes.seek(0)
+        return pdf_bytes
+
+

server/home.py

@@ -0,0 +1,66 @@
+import uuid
+from pathlib import Path
+from shiny import reactive, ui, render
+
+import os
+import sys
+sys.path.append('code')
+
+from context import (
+    get_all_jobs,
+    get_all_candidates,
+    save_candidate_context,
+    init_context
+)
+
+init_context()
+
+UPLOAD_DIR = Path(os.path.join("..", "data"))
+UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+
+def server(input, output, session):
+
+    @output
+    @render.text
+    @reactive.event(input.upload_resume_btn)
+    def upload_result():
+        print("🚨 upload_result triggered")
+
+        fileinfo = input.resume_file()
+        job_id = input.job_id_input()
+        print(f"📥 fileinfo = {fileinfo}")
+        print(f"📌 job_id = {job_id}")
+
+        if not fileinfo or not job_id:
+            return "❌ Missing file or job ID."
+
+        file_meta = fileinfo[0]
+        resume_bytes = Path(file_meta["datapath"]).read_bytes()
+
+        candidate_id = str(uuid.uuid4())
+        filename = f"{candidate_id}.pdf"
+        target_path = UPLOAD_DIR / filename
+        target_path.write_bytes(resume_bytes)
+
+        candidate_data = {
+            "candidate_id": candidate_id,
+            "job_id": job_id,
+            "Resume File": filename,
+            "Application ID": str(uuid.uuid4())
+        }
+        save_candidate_context(candidate_id, candidate_data)
+
+        print(f"✅ Uploaded {file_meta['name']} → job_id: {job_id}")
+        return f"✅ Resume uploaded and linked to `{job_id[:8]}`.\nCandidate ID: `{candidate_id}`"
+
+    @reactive.effect
+    def _populate_job_ids():
+        all_jobs = get_all_jobs()
+
+        chart_choices = {
+            job_id: f"{job_data.get('title', 'Untitled')} ({job_id[:8]})"
+            for job_id, job_data in all_jobs.items()
+        }
+
+        print(f"Job IDs: {len(chart_choices)} loaded")
+        ui.update_select("job_id_input", choices=chart_choices, selected=None)

server/interview_scheduler.py

@@ -0,0 +1,408 @@
+import sys
+import os, sys, json, io, zipfile
+import json
+import requests
+from dotenv import load_dotenv
+from shiny import reactive, render, ui
+
+# Access ../code/context.py
+
+from context import get_all_candidates
+from llm_connect import get_response
+
+from datetime import datetime
+from fpdf import FPDF
+from PyPDF2 import PdfReader
+import markdown
+
+# Load Calendly token
+load_dotenv()
+CALENDLY_API_KEY = os.getenv('CALENDLY_API_KEY')
+if not CALENDLY_API_KEY:
+    raise RuntimeError("❌ CALENDLY_API_KEY not set.")
+
+HEADERS = {
+    'Authorization': f"Bearer {CALENDLY_API_KEY}",
+    'Content-Type': 'application/json'
+}
+
+_event_url_cache = None
+
+def get_user_uri():
+    response = requests.get("https://api.calendly.com/users/me", headers=HEADERS, timeout=5)
+    response.raise_for_status()
+    return response.json()['resource']['uri']
+
+def get_event_type_link(user_uri):
+    response = requests.get(f"https://api.calendly.com/event_types?user={user_uri}", headers=HEADERS, timeout=5)
+    response.raise_for_status()
+    return response.json()['collection'][0]['scheduling_url']
+
+def schedule_interview(name, email):
+    global _event_url_cache
+    if _event_url_cache is None:
+        user_uri = get_user_uri()
+        _event_url_cache = get_event_type_link(user_uri)
+    return f"{_event_url_cache}?name={name.replace(' ', '+')}&email={email}"
+
+
+def draft_invite_email_with_llm(name, email, link, job_data):
+    prompt = (
+        f"You are a recruiter inviting a candidate to schedule an interview.\n\n"
+        f"Candidate Name: {name}\n"
+        f"Candidate Email: {email}\n\n"
+        f"Job Title: {job_data.get('title', 'Unknown')}\n"
+        f"Specialization: {job_data.get('specialization', '')}\n"
+        f"Job Description:\n{job_data.get('job_description', '')}\n\n"
+        f"Scheduling Link: {link}\n\n"
+        f"Write a professional, warm, and concise email inviting the candidate to schedule an interview. "
+        f"Include the scheduling link. Return only the email body text. No formatting or extra explanation.\n"
+    )
+
+    return get_response(
+        input=prompt,
+        template=lambda x: x,
+        llm="llama",
+        md=False,
+        temperature=0.7,
+        max_tokens=500,
+    )
+
+def export_email_as_pdf(name, email_text):
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_auto_page_break(auto=True, margin=15)
+    pdf.set_font("Arial", size=12)
+    for line in email_text.strip().split("\n"):
+        pdf.multi_cell(0, 10, line)
+    output_dir = os.path.join(os.path.dirname(__file__), "emails")
+    os.makedirs(output_dir, exist_ok=True)
+    filename = os.path.join(output_dir, f"{name.replace(' ', '_')}.pdf")
+    pdf.output(filename)
+    return filename
+
+
+
+# === MAIN SHINY SERVER FUNCTION ===
+def server(input, output, session):
+    print("✅ Entered server()")
+
+    if not hasattr(session, "_memo"):
+        session._memo = {}  # 🛠 manually initialize in-memory store
+
+    @reactive.Calc
+    def job_options():
+        raw_candidates = get_all_candidates()
+        job_ids_used = {c.get("job_id") for c in raw_candidates.values() if "job_id" in c}
+
+        path = "../data/context.json"
+        try:
+            with open(path, "r") as f:
+                full = json.load(f)
+                all_jobs = full.get("jobs", {})
+                session._memo["all_jobs"] = all_jobs
+                session._memo["all_candidates"] = full.get("candidates", {})
+
+            # Build job_id: label mapping only for jobs with candidates
+            job_choices = {
+                job_id: f"{job_data.get('title', 'Untitled')} ({job_id[:8]})"
+                for job_id, job_data in all_jobs.items()
+                if job_id in job_ids_used
+            }
+
+            print(f"📊 Loaded {len(job_choices)} job IDs with candidates")
+            return job_choices
+        except Exception as e:
+            print("❌ Failed to load job/candidate context:", e)
+            return {}
+
+
+    @output
+    @render.ui
+    def name_selector():
+        job_ids = job_options()
+        if not job_ids:
+            return ui.p("No jobs available.")
+        return ui.div(
+            ui.input_select("selected_job", "Select Job ID", choices=job_ids),
+            ui.output_ui("candidate_checkbox")
+        )
+
+    @output
+    @render.ui
+    def candidate_checkbox():
+        job_id = input.selected_job()
+        if not job_id:
+            return ui.p("Select a job to view candidates.")
+
+        candidates = session._memo.get("all_candidates", {})
+        filtered = [
+            {
+                "label": f"{c['Name']} ({c['Email']})",
+                "name": c["Name"],
+                "email": c["Email"]
+            }
+            for c in candidates.values()
+            if str(c.get("job_id", "")).strip() == str(job_id).strip()
+        ]
+
+        session._memo["filtered_candidates"] = filtered
+
+        if not filtered:
+            return ui.p("No candidates match this job.")
+
+        return ui.input_checkbox_group(
+            "selected_names",
+            "Select candidates to schedule",
+            choices=[c["label"] for c in filtered]
+        )
+
+    @output
+    @render.ui
+    @reactive.event(input.generate_links)
+    def output_links_html():
+        selected = input.selected_names()
+        if not selected:
+            return ui.p("No candidates selected.")
+
+        job_id = input.selected_job()
+        session._memo["active_job_id"] = job_id
+
+        job_data = session._memo.get("all_jobs", {}).get(job_id, {})
+        candidates = {
+            f"{c['name']} ({c['email']})": c
+            for c in session._memo.get("filtered_candidates", [])
+        }
+
+        results = []
+        pdf_paths = []
+
+        for label in selected:
+            c = candidates.get(label)
+            if not c:
+                results.append(ui.p(f"{label}: Not found"))
+                continue
+            try:
+                link = schedule_interview(c['name'], c['email'])
+                email_text = draft_invite_email_with_llm(c['name'], c['email'], link, job_data)
+
+                # Sanitize name + timestamp
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                safe_name = f"{c['name'].replace(' ', '_')}_{timestamp}"
+                filename = f"{safe_name}.pdf"
+
+                # Correct folder: milestone2/data/emails/{job_id}/
+                output_dir = f"../data/emails/{job_id}"
+
+                os.makedirs(output_dir, exist_ok=True)
+
+                # Full path to PDF file
+                pdf_path = os.path.join(output_dir, filename)
+
+                # Generate PDF
+                pdf = FPDF()
+                pdf.add_page()
+                pdf.set_auto_page_break(auto=True, margin=15)
+                pdf.set_font("Arial", size=12)
+                for line in email_text.strip().split("\n"):
+                    pdf.multi_cell(0, 10, line)
+                pdf.output(pdf_path)
+
+                # Store PDF
+                pdf_paths.append(pdf_path)
+
+                results.append(
+                    ui.HTML(f"<p><b>{c['name']}</b>: <a href='{link}' target='_blank'>📅 Schedule</a> — PDF ready</p>")
+                )
+
+            except Exception as e:
+                results.append(ui.p(f"{c['name']}: ERROR - {e}"))
+
+        session._memo["pdf_paths"] = pdf_paths
+        return ui.div(*results)
+
+
+    @output
+    @render.ui
+    @reactive.event(input.generate_links)  # 🔁 Trigger update after generate button
+    def pdf_selector():
+        files = session._memo.get("pdf_paths", [])
+        if not files:
+            return ui.p("No PDFs to preview.")
+
+        default_pdf = os.path.basename(files[0])
+        return ui.input_select(
+            "selected_pdf",
+            "Preview PDF",
+            choices=[os.path.basename(f) for f in files],
+            selected=default_pdf
+        )
+
+
+    @output
+    @render.ui
+    @reactive.Calc
+    def pdf_preview():
+        selected = input.selected_pdf()
+        job_id = session._memo.get("active_job_id", "").strip()
+
+        # ✅ DEBUG: show raw values
+        print("📄 pdf_preview triggered")
+        print("🔍 selected_pdf:", selected)
+        print("📁 active_job_id:", job_id)
+
+        if not selected:
+            return ui.p("⚠️ No PDF selected.")
+        if not job_id:
+            return ui.p("⚠️ No active job selected.")
+
+        file_path = os.path.abspath(
+            os.path.join(
+                os.path.dirname(__file__),
+                "..", "..", "milestone2", "data", "emails", job_id,
+                os.path.basename(selected)
+            )
+        )
+
+
+        if not os.path.exists(file_path):
+            print("❌ File not found on disk.")
+            return ui.p(f"❌ PDF not found: {selected}")
+
+        try:
+            reader = PdfReader(file_path)
+            text = "\n".join([page.extract_text() or "" for page in reader.pages])
+            print("✅ PDF text extracted.")
+        except Exception as e:
+            print("❌ Exception during PDF read:", e)
+            return ui.p(f"❌ Failed to extract PDF text: {e}")
+
+        html = markdown.markdown(text)
+        return ui.HTML(f"""
+            <div style='padding: 1em; font-family: Georgia, serif; font-size: 1rem; line-height: 1.6;'>
+                {html}
+            </div>
+        """)
+
+
+
+
+    @output
+    @render.download(filename="Interview_Emails.zip")
+    def download_emails():
+        pdf_paths = session._memo.get("pdf_paths", [])
+        if not pdf_paths:
+            return None  # nothing to download
+
+        job_id = session._memo.get("active_job_id", "").strip()
+        zip_path = f"../data/emails/{job_id}/Interview_Emails.zip"
+
+        if os.path.exists(zip_path):
+            os.remove(zip_path)
+
+        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
+            for path in pdf_paths:
+                zipf.write(path, arcname=os.path.basename(path))
+
+        return zip_path
+
+    @output
+    @render.text
+    @reactive.event(input.submit_chat)
+    def refined_output():
+        user_instruction = input.chat_prompt().strip()
+        selected = input.selected_pdf()
+        job_id = session._memo.get("active_job_id", "").strip()
+
+        if not selected or not job_id:
+            return "⚠️ Select a PDF to edit."
+
+        # Load original text
+        pdf_path = f"../data/emails/{job_id}/{selected}"
+
+        if not os.path.exists(pdf_path):
+            return "❌ Could not find the original PDF."
+
+        reader = PdfReader(pdf_path)
+        original_text = "\n".join([page.extract_text() or "" for page in reader.pages])
+
+        # Call your LLM with edit prompt
+        full_prompt = (
+            f"The following is an email invitation:\n\n"
+            f"{original_text}\n\n"
+            f"User instruction: {user_instruction}\n\n"
+            f"Please revise the email accordingly. Return only the revised email."
+        )
+
+        try:
+            revised = get_response(
+                input=full_prompt,
+                template=lambda x: x,
+                llm="llama",
+                md=False,
+                temperature=0.6,
+                max_tokens=600
+            )
+            return revised.strip()
+        except Exception as e:
+            return f"❌ LLM failed: {e}"
+        
+
+    @reactive.effect
+    @reactive.event(input.toggle_edit)
+    def load_pdf_for_editing():
+        selected = input.selected_pdf()
+        job_id = session._memo.get("active_job_id", "").strip()
+        if not selected or not job_id:
+            return
+
+        file_path = f"../data/emails/{job_id}/{selected}"
+
+        if not os.path.exists(file_path):
+            return
+        reader = PdfReader(file_path)
+        text = "\n".join([page.extract_text() or "" for page in reader.pages])
+
+        ui.update_text_area("edit_text", value=text)
+
+
+
+    @reactive.effect
+    @reactive.event(input.save_edit)
+    def save_edited_pdf():
+        selected = input.selected_pdf()
+        job_id = session._memo.get("active_job_id", "").strip()
+        new_text = input.edit_text().strip()
+
+        if not selected or not job_id or not new_text:
+            return
+
+        file_path = f"../data/emails/{job_id}/{selected}"
+
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_auto_page_break(auto=True, margin=15)
+        pdf.set_font("Arial", size=12)
+        for line in new_text.splitlines():
+            pdf.multi_cell(0, 10, line)
+        pdf.output(file_path)
+
+        print(f"✅ Overwrote PDF: {file_path}")
+
+        session.send_input_message("selected_pdf", {"value": selected})
+
+
+    @output
+    @render.ui
+    def edit_ui_block():
+        if input.toggle_edit() % 2 == 1:
+            return ui.div(
+                ui.input_text_area("edit_text", "Edit Email Text:", rows=20),
+                ui.input_action_button("save_edit", "💾 Overwrite PDF"),
+                style="margin-top: 1em;"
+            )
+        else:
+            return None
+
+
+

server/job_creation.py

@@ -0,0 +1,131 @@
+from shiny import reactive, render, ui
+import uuid
+import os
+import markdown
+from llm_connect import get_response
+from context import save_job_context
+import json
+
+# ✅ Global reactive cache shared across handlers
+response_cache = reactive.Value("")
+
+
+def call_chatbot(user_input: str, session_id: str) -> str:
+    prompt = (
+        "You are an intelligent recruiting assistant.\n"
+        "If the user asks to generate a job description, do so with sections:\n"
+        "- About the Role\n- Responsibilities\n- Required Skills\n"
+        "- Preferred Qualifications\n- Company Culture Highlights\n"
+        "- Salary and Visa Requirements\n\n"
+        "If the user asks anything else, just respond helpfully.\n\n"
+        f"User: {user_input}"
+    )
+    return get_response(input=prompt, template=lambda x: x, llm="llama", md=False, temperature=0.9, max_tokens=1000).strip()
+
+
+def extract_job_metadata(job_description: str) -> dict:
+    prompt = f"""
+You are a structured data extraction assistant. 
+Given a job description, extract these 3 fields:
+
+1. "job_title": (string) The job title.
+2. "specialization": (string) The domain or technical area, like 'Data Science', 'Finance', or 'Healthcare'.
+3. "years_required": (integer or null) Minimum years of experience mentioned. If not present, return null.
+
+Respond in EXACTLY this JSON format:
+
+{{
+  "job_title": "...",
+  "specialization": "...",
+  "years_required": ...
+}}
+
+Job Description:
+\"\"\"{job_description}\"\"\"
+"""
+    response = get_response(
+        input=prompt,
+        template=lambda x: x,
+        llm="llama",
+        md=False,
+        temperature=0.2,
+        max_tokens=200
+    )
+
+    try:
+        return json.loads(response)
+    except Exception as e:
+        print(f"⚠️ Failed to parse metadata response: {e}")
+        return {
+            "job_title": None,
+            "specialization": None,
+            "years_required": None
+        }
+
+
+def server(input, output, session):
+    session_id = str(uuid.uuid4())
+    chat_status = reactive.Value("")
+    save_status = reactive.Value("")
+
+    @output
+    @render.ui
+    @reactive.event(input.submit_btn)
+    def job_chat_response():
+        user_input = input.user_input().strip()
+
+        if not user_input:
+            return ui.HTML("<i>⚠️ Please enter a prompt.</i>")
+
+        chat_status.set("💬 Thinking...")
+
+        try:
+            raw_response = call_chatbot(user_input, session_id)
+            response_cache.set(raw_response)
+            html = markdown.markdown(raw_response, extensions=["extra", "sane_lists"])
+        except Exception as e:
+            html = f"<b>❌ Error:</b> {str(e)}"
+            response_cache.set("")
+
+        chat_status.set("")
+        return ui.HTML(html)
+
+
+    @reactive.effect()
+    @reactive.event(input.save_job_btn)
+    def save_generated_job():
+        print("💥 Save button clicked")
+        raw_response = response_cache.get().strip()
+        if not raw_response:
+            print("⚠️ No job response cached.")
+            save_status.set("⚠️ No job to save.")
+            return
+
+        try:
+            print("🔍 Extracting metadata from response...")
+            metadata = extract_job_metadata(raw_response)
+            print("✅ Metadata extracted:")
+            print(json.dumps(metadata, indent=2))
+
+            job_id = str(uuid.uuid4())
+            job_data = {
+                "job_id": job_id,
+                "title": metadata.get("job_title") or "Untitled",
+                "specialization": metadata.get("specialization") or "General",
+                "years_required": metadata.get("years_required"),
+                "job_description": raw_response
+            }
+
+            save_job_context(job_id, job_data)
+            save_status.set(f"✅ Job saved: {job_data['title']}")
+            print(f"✅ Job saved to context: {job_id}")
+
+        except Exception as e:
+            error_msg = f"❌ Failed to save job: {e}"
+            print(error_msg)
+            save_status.set(error_msg)
+
+    @output(id="save_status_ui")
+    @render.text
+    def render_save_status():
+        return save_status.get()

server/plot_generation.py

@@ -0,0 +1,277 @@
+import os
+import sys
+sys.path.append('../code')
+
+import pandas as pd
+import numpy as np
+from dotenv import load_dotenv
+import json
+from IPython.display import Markdown, display
+import markdown
+from shiny import reactive, render, ui, req
+from shiny.express import render as render_express
+from google.api_core.exceptions import ResourceExhausted
+from pathlib import Path
+import tempfile
+
+load_dotenv()
+
+import google.generativeai as genai
+from google.generativeai.types import FunctionDeclaration, Tool
+
+from llm_connect import get_response
+from context import get_all_candidates, get_all_jobs
+import uuid
+
+
+# === TOOL FUNCTION === #
+
+import plotly.express as px
+import plotly.io as pio
+
+def generate_plot(df: pd.DataFrame, chart_x: str, chart_y: str = None, chart_type: str = "scatter"):
+    width = 1000
+    height = 600
+
+    if chart_x not in df.columns:
+        raise ValueError(f"Column '{chart_x}' not in DataFrame.")
+    if chart_type != "histogram" and (not chart_y or chart_y not in df.columns):
+        raise ValueError(f"Column '{chart_y}' not in DataFrame.")
+
+    if chart_type == "scatter":
+        fig = px.scatter(df, x=chart_x, y=chart_y, title=f"Scatter Plot: {chart_y} vs {chart_x}", width=width, height=height)
+    elif chart_type == "bar":
+        fig = px.bar(df, x=chart_x, y=chart_y, title=f"Bar Chart: {chart_y} vs {chart_x}", width=width, height=height)
+    elif chart_type == "line":
+        fig = px.line(df, x=chart_x, y=chart_y, title=f"Line Chart: {chart_y} vs {chart_x}", width=width, height=height)
+    elif chart_type == "histogram":
+        fig = px.histogram(df, x=chart_x, title=f"Histogram of {chart_x}", width=width, height=height)
+    else:
+        raise ValueError(f"Unsupported chart type: {chart_type}")
+
+    return fig
+
+
+
+# === REGISTER TOOL === #
+plot_func_schema = FunctionDeclaration(
+    name="generate_plot",
+    description="Generate and return a chart from candidate data.",
+    parameters={
+        "type": "object",
+        "properties": {
+            "chart_x": {
+                "type": "string",
+                "description": "The x-axis column to plot."
+            },
+            "chart_y": {
+                "type": "string",
+                "description": "The y-axis column to plot (omit for histogram)."
+            },
+            "chart_type": {
+                "type": "string",
+                "enum": ["scatter", "bar", "line", "histogram"],
+                "description": "Type of chart to render."
+            }
+        },
+        "required": ["chart_x", "chart_type"]
+    }
+)
+
+plot_tool = Tool(function_declarations=[plot_func_schema])
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+model = genai.GenerativeModel("gemini-2.0-flash", tools=[plot_tool])
+
+
+# === MAIN SHINY SERVER FUNCTION ===
+
+def server(input, output, session):
+    print("✅ Entered server()")
+
+    last_cols = reactive.Value(('', ''))
+    last_type = reactive.Value('')
+    last_chat = reactive.Value(None)
+    last_chart_spec = reactive.Value(None)
+
+    @reactive.effect
+    def _populate_job_ids():
+        raw_candidates = get_all_candidates()
+        job_ids_used = {c.get("job_id") for c in raw_candidates.values() if "job_id" in c}
+
+        all_jobs = get_all_jobs()
+
+        chart_choices = {
+            job_id: f"{job_data.get('title', 'Untitled')} ({job_id[:8]})"
+            for job_id, job_data in all_jobs.items()
+            if job_id in job_ids_used
+        }
+
+        print(f"📊 Chart Job IDs: {len(chart_choices)} loaded")
+        ui.update_select("chart_job_id", choices=chart_choices, selected="")
+    
+    @reactive.Calc
+    def candidates():
+        raw = get_all_candidates()
+        filtered_job = input.chart_job_id()
+        if not filtered_job:
+            print("⚠️ No job selected.")
+            return pd.DataFrame()
+        df = pd.DataFrame([c for c in raw.values() if c.get("job_id") == filtered_job])
+        return df
+    
+    @reactive.Calc
+    def plot_inputs():
+        df = candidates()
+        chart_x = input.chart_x()
+        chart_y = input.chart_y()
+        chart_type = input.chart_type()
+
+        if df.empty or not chart_x or (chart_type != "histogram" and not chart_y):
+            return None
+
+        return (df, chart_x, chart_y, chart_type)
+
+
+    @reactive.effect
+    def column_dropdowns():
+        selected_job = input.chart_job_id()
+        if not selected_job:
+            # Clear dropdowns if no job selected
+            ui.update_select("chart_x", choices=[], selected="")
+            ui.update_select("chart_y", choices=[], selected="")
+            return
+        
+        df = candidates()
+        if df.empty:
+            return 
+        exclude = {"Name", "Email", "Resume File", "Key Skills", "Llama Summary", "Gemini Summary",
+                   "Note", "candidate_id", "job_id", "application_date", "source"}
+        valid = [c for c in df.columns if c not in exclude]
+        default_x = valid[0] if valid else ""
+        default_y = valid[1] if len(valid) > 1 else default_x
+        ui.update_select("chart_x", choices=valid, selected=default_x)
+        ui.update_select("chart_y", choices=valid, selected=default_y)
+    
+
+    @output
+    @render.ui
+    @reactive.event(input.generate_plot)
+    def generate_display_plot():
+        print("⚡ generate_display_plot triggered")
+
+        inputs = plot_inputs()
+        if inputs is None:
+            print("❌ Inputs not ready")
+            return ui.p("Please complete all selections before generating a chart.")
+
+        df, chart_x, chart_y, chart_type = inputs
+
+        try:
+            fig = generate_plot(df, chart_x, chart_y if chart_type != "histogram" else None, chart_type)
+            html = fig.to_html(full_html=False, include_plotlyjs="div")
+
+            last_chart_spec.set(fig.to_json())
+            last_cols.set((chart_x, chart_y))
+            last_type.set(chart_type)
+
+            return ui.HTML(html + f"<div style='display:none'>{uuid.uuid4()}</div>")
+
+        except Exception as e:
+            print(f"❌ Chart generation failed: {e}")
+            return ui.p(f"Chart generation error: {e}")
+
+
+
+        
+    @output
+    @render.ui
+    @reactive.event(input.generate_plot)
+    def llm_explain_plot():
+        df = candidates()
+        chart_x = input.chart_x()
+        chart_y = input.chart_y()
+        chart_type = input.chart_type()
+        spec_json = last_chart_spec.get()
+
+        if df.empty or not chart_x or (chart_type != "histogram" and not chart_y):
+            return ui.p("⚠️ Please select valid columns and chart type.")
+
+        try:
+            columns = [chart_x] + ([chart_y] if chart_y else [])
+            summary = df[columns].describe().to_string()
+
+            if spec_json:
+                plot = pio.from_json(spec_json)
+
+            prompt = (
+                f"Here is the data, summary and plot of {chart_x} vs {chart_y} used to generate a {chart_type} plot"
+                f"Plot: \n{plot}\n\n"
+                f"Data: {df}\n\n"
+                f"Summary: {summary}\n\n"
+                "Explain the chart to a recruiter, focusing on insights, trends and implications for hiring.\n\n"
+                "Do not call any tool or function. Respond in natural language only."
+                "Be detailed and be clear of why the chart shapes up the way it did."
+            )
+
+            chat = model.start_chat()
+            response = chat.send_message(prompt)
+            explanation = markdown.markdown(response.text.strip())
+            last_chat.set(chat)
+        except Exception as e:
+            explanation = f"⚠️ Gemini error: {str(e)}"
+
+        return ui.HTML(f"{explanation}")
+
+    @output
+    @render.ui
+    @reactive.event(input.chart_chat_send)
+    def chat_followup():
+        user_msg = input.chart_chat_input().strip()
+        chat = last_chat.get()
+        df = candidates()
+
+        chart_x, chart_y = last_cols.get()
+        chart_type = last_type.get()
+        spec_json = last_chart_spec.get()
+
+        if not user_msg:
+            return ui.HTML("⚠️ Please enter a follow-up question.")
+        if not chat:
+            return ui.HTML("⚠️ Please generate a chart first.")
+        if not chart_x or not chart_type:
+            return ui.HTML("⚠️ Please choose chart variables and/or type first.")
+        
+        # Provide full data context for Gemini: 10 rows, all columns
+        clean_df = df.drop(columns=["Resume File", "Llama Summary", "Gemini Summary"], errors="ignore")
+        sample_json = json.dumps(clean_df.head(10).to_dict(orient="records"), indent=2)
+            
+        if spec_json:
+            plot = pio.from_json(spec_json)
+
+        followup = (
+            f"Here is a sample of the first 10 rows of candidate data: \n{sample_json}\n\n"
+            f"This is the generated {chart_type} chart between '{chart_x}' and '{chart_y}:"
+            f"Plot: {plot}"
+            f"The user asked: \"{user_msg}\"\n\n"
+            f"Respond helpfully based on the chart context and question. Be detailed and clear in your explanation"
+        )
+
+        try:
+            chat = model.start_chat()
+            response = chat.send_message(followup)
+            if hasattr(response, "text") and response.text:
+                explanation = markdown.markdown(response.text.strip())
+            else:
+                explanation = "⚠️ Gemini responded with a tool function call instead of natural language. Try adjusting the prompt."
+        except ResourceExhausted:
+            explanation = "<b>❌ Gemini quota exceeded. Try again soon.</b>"
+        except Exception as e:
+            explanation = f"<b>❌ Gemini error:</b> {str(e)}"
+
+        return ui.HTML(explanation)
+    
+    @reactive.effect
+    def log_generate_trigger():
+        _ = input.generate_plot()
+        print("👆 generate_plot button was clicked")
+

shared.py

@@ -1,6 +0,0 @@
-from pathlib import Path
-
-import pandas as pd
-
-app_dir = Path(__file__).parent
-tips = pd.read_csv(app_dir / "tips.csv")

styles.css

@@ -1,12 +0,0 @@
-:root {
-  --bslib-sidebar-main-bg: #f8f8f8;
-}
-
-.popover {
-  --bs-popover-header-bg: #222;
-  --bs-popover-header-color: #fff;
-}
-
-.popover .btn-close {
-  filter: var(--bs-btn-close-white-filter);
-}

styles/custom.css

@@ -0,0 +1,163 @@
+/* ----------------- */
+/* 🌞 Base Light Theme */
+/* ----------------- */
+body {
+    background-color: #f4f6f8;
+    font-family: 'Inter', 'Segoe UI', sans-serif;
+    font-size: 16px;
+    color: #212529;
+    margin: 0;
+    padding: 0;
+    transition: background-color 0.3s ease, color 0.3s ease;
+}
+
+.container {
+    max-width: 1200px;
+    margin: auto;
+    padding: 2em;
+}
+
+/* Typography */
+h1, h2, h3, h4, h5, h6,
+p, li, label, span {
+    color: #1e2b3a;
+    margin-bottom: 1em;
+    font-weight: 500;
+}
+
+/* Cards */
+.card {
+    background: linear-gradient(to bottom right, #ffffff, #f9fbfd);
+    border-radius: 14px;
+    padding: 2em;
+    box-shadow: 0 6px 16px rgba(0,0,0,0.05);
+    margin-bottom: 2em;
+    animation: fadeInUp 0.4s ease forwards;
+}
+
+/* Inputs */
+input[type="text"], select, textarea {
+    width: 100%;
+    padding: 0.75em 1em;
+    border: 1px solid #ced4da;
+    border-radius: 10px;
+    background-color: #ffffff;
+    font-size: 1rem;
+    transition: background-color 0.3s, border-color 0.3s, color 0.3s, transform 0.2s;
+}
+
+input:focus, textarea:focus, select:focus {
+    border-color: #007bff;
+    outline: none;
+    box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.2);
+    transform: scale(1.01);
+}
+
+/* Buttons */
+button, .btn {
+    background: linear-gradient(to right, #0d6efd, #0b5ed7);
+    border: none;
+    color: #ffffff;
+    padding: 0.75em 1.5em;
+    border-radius: 10px;
+    font-size: 1rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: background 0.2s ease, transform 0.1s ease;
+}
+
+button:hover, .btn:hover {
+    background: linear-gradient(to right, #0b5ed7, #0a53be);
+}
+
+button:active, .btn:active {
+    transform: scale(0.96);
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.15) inset;
+}
+
+/* Navigation (Light Mode) */
+.navbar,
+.nav-tabs,
+.nav-link,
+.nav-item {
+    background-color: #ffffff;
+    color: #212529;
+    border-color: #dee2e6;
+    transition: background-color 0.3s, color 0.3s;
+}
+
+.nav-link.active {
+    background-color: #e9ecef;
+    color: #000;
+}
+
+
+/* ----------------- */
+/* ✨ Animations */
+/* ----------------- */
+
+/* Global transition for everything */
+body, body * {
+    transition:
+        background-color 0.3s ease,
+        color 0.3s ease,
+        border-color 0.3s ease,
+        box-shadow 0.3s ease,
+        transform 0.2s ease;
+}
+
+/* Fade-in for cards */
+@keyframes fadeInUp {
+    from {
+        opacity: 0;
+        transform: translateY(20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+/* Nav hover underline */
+.nav-link {
+    position: relative;
+}
+
+.nav-link::after {
+    content: "";
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    height: 2px;
+    width: 0%;
+    background-color: currentColor;
+    transition: width 0.3s ease;
+}
+
+.nav-link:hover::after {
+    width: 100%;
+}
+
+/* Modal / panel zoom-in (if you use them) */
+.modal, .panel, .popup {
+    opacity: 0;
+    transform: scale(0.96);
+    animation: zoomIn 0.3s ease forwards;
+}
+
+@keyframes zoomIn {
+    to {
+        opacity: 1;
+        transform: scale(1);
+    }
+}
+
+/* Tab transition */
+.tab-pane {
+    opacity: 0;
+    transition: opacity 0.3s ease;
+}
+
+.tab-pane.active {
+    opacity: 1;
+}

tips.csv

@@ -1,245 +0,0 @@
-total_bill,tip,sex,smoker,day,time,size
-16.99,1.01,Female,No,Sun,Dinner,2
-10.34,1.66,Male,No,Sun,Dinner,3
-21.01,3.5,Male,No,Sun,Dinner,3
-23.68,3.31,Male,No,Sun,Dinner,2
-24.59,3.61,Female,No,Sun,Dinner,4
-25.29,4.71,Male,No,Sun,Dinner,4
-8.77,2.0,Male,No,Sun,Dinner,2
-26.88,3.12,Male,No,Sun,Dinner,4
-15.04,1.96,Male,No,Sun,Dinner,2
-14.78,3.23,Male,No,Sun,Dinner,2
-10.27,1.71,Male,No,Sun,Dinner,2
-35.26,5.0,Female,No,Sun,Dinner,4
-15.42,1.57,Male,No,Sun,Dinner,2
-18.43,3.0,Male,No,Sun,Dinner,4
-14.83,3.02,Female,No,Sun,Dinner,2
-21.58,3.92,Male,No,Sun,Dinner,2
-10.33,1.67,Female,No,Sun,Dinner,3
-16.29,3.71,Male,No,Sun,Dinner,3
-16.97,3.5,Female,No,Sun,Dinner,3
-20.65,3.35,Male,No,Sat,Dinner,3
-17.92,4.08,Male,No,Sat,Dinner,2
-20.29,2.75,Female,No,Sat,Dinner,2
-15.77,2.23,Female,No,Sat,Dinner,2
-39.42,7.58,Male,No,Sat,Dinner,4
-19.82,3.18,Male,No,Sat,Dinner,2
-17.81,2.34,Male,No,Sat,Dinner,4
-13.37,2.0,Male,No,Sat,Dinner,2
-12.69,2.0,Male,No,Sat,Dinner,2
-21.7,4.3,Male,No,Sat,Dinner,2
-19.65,3.0,Female,No,Sat,Dinner,2
-9.55,1.45,Male,No,Sat,Dinner,2
-18.35,2.5,Male,No,Sat,Dinner,4
-15.06,3.0,Female,No,Sat,Dinner,2
-20.69,2.45,Female,No,Sat,Dinner,4
-17.78,3.27,Male,No,Sat,Dinner,2
-24.06,3.6,Male,No,Sat,Dinner,3
-16.31,2.0,Male,No,Sat,Dinner,3
-16.93,3.07,Female,No,Sat,Dinner,3
-18.69,2.31,Male,No,Sat,Dinner,3
-31.27,5.0,Male,No,Sat,Dinner,3
-16.04,2.24,Male,No,Sat,Dinner,3
-17.46,2.54,Male,No,Sun,Dinner,2
-13.94,3.06,Male,No,Sun,Dinner,2
-9.68,1.32,Male,No,Sun,Dinner,2
-30.4,5.6,Male,No,Sun,Dinner,4
-18.29,3.0,Male,No,Sun,Dinner,2
-22.23,5.0,Male,No,Sun,Dinner,2
-32.4,6.0,Male,No,Sun,Dinner,4
-28.55,2.05,Male,No,Sun,Dinner,3
-18.04,3.0,Male,No,Sun,Dinner,2
-12.54,2.5,Male,No,Sun,Dinner,2
-10.29,2.6,Female,No,Sun,Dinner,2
-34.81,5.2,Female,No,Sun,Dinner,4
-9.94,1.56,Male,No,Sun,Dinner,2
-25.56,4.34,Male,No,Sun,Dinner,4
-19.49,3.51,Male,No,Sun,Dinner,2
-38.01,3.0,Male,Yes,Sat,Dinner,4
-26.41,1.5,Female,No,Sat,Dinner,2
-11.24,1.76,Male,Yes,Sat,Dinner,2
-48.27,6.73,Male,No,Sat,Dinner,4
-20.29,3.21,Male,Yes,Sat,Dinner,2
-13.81,2.0,Male,Yes,Sat,Dinner,2
-11.02,1.98,Male,Yes,Sat,Dinner,2
-18.29,3.76,Male,Yes,Sat,Dinner,4
-17.59,2.64,Male,No,Sat,Dinner,3
-20.08,3.15,Male,No,Sat,Dinner,3
-16.45,2.47,Female,No,Sat,Dinner,2
-3.07,1.0,Female,Yes,Sat,Dinner,1
-20.23,2.01,Male,No,Sat,Dinner,2
-15.01,2.09,Male,Yes,Sat,Dinner,2
-12.02,1.97,Male,No,Sat,Dinner,2
-17.07,3.0,Female,No,Sat,Dinner,3
-26.86,3.14,Female,Yes,Sat,Dinner,2
-25.28,5.0,Female,Yes,Sat,Dinner,2
-14.73,2.2,Female,No,Sat,Dinner,2
-10.51,1.25,Male,No,Sat,Dinner,2
-17.92,3.08,Male,Yes,Sat,Dinner,2
-27.2,4.0,Male,No,Thur,Lunch,4
-22.76,3.0,Male,No,Thur,Lunch,2
-17.29,2.71,Male,No,Thur,Lunch,2
-19.44,3.0,Male,Yes,Thur,Lunch,2
-16.66,3.4,Male,No,Thur,Lunch,2
-10.07,1.83,Female,No,Thur,Lunch,1
-32.68,5.0,Male,Yes,Thur,Lunch,2
-15.98,2.03,Male,No,Thur,Lunch,2
-34.83,5.17,Female,No,Thur,Lunch,4
-13.03,2.0,Male,No,Thur,Lunch,2
-18.28,4.0,Male,No,Thur,Lunch,2
-24.71,5.85,Male,No,Thur,Lunch,2
-21.16,3.0,Male,No,Thur,Lunch,2
-28.97,3.0,Male,Yes,Fri,Dinner,2
-22.49,3.5,Male,No,Fri,Dinner,2
-5.75,1.0,Female,Yes,Fri,Dinner,2
-16.32,4.3,Female,Yes,Fri,Dinner,2
-22.75,3.25,Female,No,Fri,Dinner,2
-40.17,4.73,Male,Yes,Fri,Dinner,4
-27.28,4.0,Male,Yes,Fri,Dinner,2
-12.03,1.5,Male,Yes,Fri,Dinner,2
-21.01,3.0,Male,Yes,Fri,Dinner,2
-12.46,1.5,Male,No,Fri,Dinner,2
-11.35,2.5,Female,Yes,Fri,Dinner,2
-15.38,3.0,Female,Yes,Fri,Dinner,2
-44.3,2.5,Female,Yes,Sat,Dinner,3
-22.42,3.48,Female,Yes,Sat,Dinner,2
-20.92,4.08,Female,No,Sat,Dinner,2
-15.36,1.64,Male,Yes,Sat,Dinner,2
-20.49,4.06,Male,Yes,Sat,Dinner,2
-25.21,4.29,Male,Yes,Sat,Dinner,2
-18.24,3.76,Male,No,Sat,Dinner,2
-14.31,4.0,Female,Yes,Sat,Dinner,2
-14.0,3.0,Male,No,Sat,Dinner,2
-7.25,1.0,Female,No,Sat,Dinner,1
-38.07,4.0,Male,No,Sun,Dinner,3
-23.95,2.55,Male,No,Sun,Dinner,2
-25.71,4.0,Female,No,Sun,Dinner,3
-17.31,3.5,Female,No,Sun,Dinner,2
-29.93,5.07,Male,No,Sun,Dinner,4
-10.65,1.5,Female,No,Thur,Lunch,2
-12.43,1.8,Female,No,Thur,Lunch,2
-24.08,2.92,Female,No,Thur,Lunch,4
-11.69,2.31,Male,No,Thur,Lunch,2
-13.42,1.68,Female,No,Thur,Lunch,2
-14.26,2.5,Male,No,Thur,Lunch,2
-15.95,2.0,Male,No,Thur,Lunch,2
-12.48,2.52,Female,No,Thur,Lunch,2
-29.8,4.2,Female,No,Thur,Lunch,6
-8.52,1.48,Male,No,Thur,Lunch,2
-14.52,2.0,Female,No,Thur,Lunch,2
-11.38,2.0,Female,No,Thur,Lunch,2
-22.82,2.18,Male,No,Thur,Lunch,3
-19.08,1.5,Male,No,Thur,Lunch,2
-20.27,2.83,Female,No,Thur,Lunch,2
-11.17,1.5,Female,No,Thur,Lunch,2
-12.26,2.0,Female,No,Thur,Lunch,2
-18.26,3.25,Female,No,Thur,Lunch,2
-8.51,1.25,Female,No,Thur,Lunch,2
-10.33,2.0,Female,No,Thur,Lunch,2
-14.15,2.0,Female,No,Thur,Lunch,2
-16.0,2.0,Male,Yes,Thur,Lunch,2
-13.16,2.75,Female,No,Thur,Lunch,2
-17.47,3.5,Female,No,Thur,Lunch,2
-34.3,6.7,Male,No,Thur,Lunch,6
-41.19,5.0,Male,No,Thur,Lunch,5
-27.05,5.0,Female,No,Thur,Lunch,6
-16.43,2.3,Female,No,Thur,Lunch,2
-8.35,1.5,Female,No,Thur,Lunch,2
-18.64,1.36,Female,No,Thur,Lunch,3
-11.87,1.63,Female,No,Thur,Lunch,2
-9.78,1.73,Male,No,Thur,Lunch,2
-7.51,2.0,Male,No,Thur,Lunch,2
-14.07,2.5,Male,No,Sun,Dinner,2
-13.13,2.0,Male,No,Sun,Dinner,2
-17.26,2.74,Male,No,Sun,Dinner,3
-24.55,2.0,Male,No,Sun,Dinner,4
-19.77,2.0,Male,No,Sun,Dinner,4
-29.85,5.14,Female,No,Sun,Dinner,5
-48.17,5.0,Male,No,Sun,Dinner,6
-25.0,3.75,Female,No,Sun,Dinner,4
-13.39,2.61,Female,No,Sun,Dinner,2
-16.49,2.0,Male,No,Sun,Dinner,4
-21.5,3.5,Male,No,Sun,Dinner,4
-12.66,2.5,Male,No,Sun,Dinner,2
-16.21,2.0,Female,No,Sun,Dinner,3
-13.81,2.0,Male,No,Sun,Dinner,2
-17.51,3.0,Female,Yes,Sun,Dinner,2
-24.52,3.48,Male,No,Sun,Dinner,3
-20.76,2.24,Male,No,Sun,Dinner,2
-31.71,4.5,Male,No,Sun,Dinner,4
-10.59,1.61,Female,Yes,Sat,Dinner,2
-10.63,2.0,Female,Yes,Sat,Dinner,2
-50.81,10.0,Male,Yes,Sat,Dinner,3
-15.81,3.16,Male,Yes,Sat,Dinner,2
-7.25,5.15,Male,Yes,Sun,Dinner,2
-31.85,3.18,Male,Yes,Sun,Dinner,2
-16.82,4.0,Male,Yes,Sun,Dinner,2
-32.9,3.11,Male,Yes,Sun,Dinner,2
-17.89,2.0,Male,Yes,Sun,Dinner,2
-14.48,2.0,Male,Yes,Sun,Dinner,2
-9.6,4.0,Female,Yes,Sun,Dinner,2
-34.63,3.55,Male,Yes,Sun,Dinner,2
-34.65,3.68,Male,Yes,Sun,Dinner,4
-23.33,5.65,Male,Yes,Sun,Dinner,2
-45.35,3.5,Male,Yes,Sun,Dinner,3
-23.17,6.5,Male,Yes,Sun,Dinner,4
-40.55,3.0,Male,Yes,Sun,Dinner,2
-20.69,5.0,Male,No,Sun,Dinner,5
-20.9,3.5,Female,Yes,Sun,Dinner,3
-30.46,2.0,Male,Yes,Sun,Dinner,5
-18.15,3.5,Female,Yes,Sun,Dinner,3
-23.1,4.0,Male,Yes,Sun,Dinner,3
-15.69,1.5,Male,Yes,Sun,Dinner,2
-19.81,4.19,Female,Yes,Thur,Lunch,2
-28.44,2.56,Male,Yes,Thur,Lunch,2
-15.48,2.02,Male,Yes,Thur,Lunch,2
-16.58,4.0,Male,Yes,Thur,Lunch,2
-7.56,1.44,Male,No,Thur,Lunch,2
-10.34,2.0,Male,Yes,Thur,Lunch,2
-43.11,5.0,Female,Yes,Thur,Lunch,4
-13.0,2.0,Female,Yes,Thur,Lunch,2
-13.51,2.0,Male,Yes,Thur,Lunch,2
-18.71,4.0,Male,Yes,Thur,Lunch,3
-12.74,2.01,Female,Yes,Thur,Lunch,2
-13.0,2.0,Female,Yes,Thur,Lunch,2
-16.4,2.5,Female,Yes,Thur,Lunch,2
-20.53,4.0,Male,Yes,Thur,Lunch,4
-16.47,3.23,Female,Yes,Thur,Lunch,3
-26.59,3.41,Male,Yes,Sat,Dinner,3
-38.73,3.0,Male,Yes,Sat,Dinner,4
-24.27,2.03,Male,Yes,Sat,Dinner,2
-12.76,2.23,Female,Yes,Sat,Dinner,2
-30.06,2.0,Male,Yes,Sat,Dinner,3
-25.89,5.16,Male,Yes,Sat,Dinner,4
-48.33,9.0,Male,No,Sat,Dinner,4
-13.27,2.5,Female,Yes,Sat,Dinner,2
-28.17,6.5,Female,Yes,Sat,Dinner,3
-12.9,1.1,Female,Yes,Sat,Dinner,2
-28.15,3.0,Male,Yes,Sat,Dinner,5
-11.59,1.5,Male,Yes,Sat,Dinner,2
-7.74,1.44,Male,Yes,Sat,Dinner,2
-30.14,3.09,Female,Yes,Sat,Dinner,4
-12.16,2.2,Male,Yes,Fri,Lunch,2
-13.42,3.48,Female,Yes,Fri,Lunch,2
-8.58,1.92,Male,Yes,Fri,Lunch,1
-15.98,3.0,Female,No,Fri,Lunch,3
-13.42,1.58,Male,Yes,Fri,Lunch,2
-16.27,2.5,Female,Yes,Fri,Lunch,2
-10.09,2.0,Female,Yes,Fri,Lunch,2
-20.45,3.0,Male,No,Sat,Dinner,4
-13.28,2.72,Male,No,Sat,Dinner,2
-22.12,2.88,Female,Yes,Sat,Dinner,2
-24.01,2.0,Male,Yes,Sat,Dinner,4
-15.69,3.0,Male,Yes,Sat,Dinner,3
-11.61,3.39,Male,No,Sat,Dinner,2
-10.77,1.47,Male,No,Sat,Dinner,2
-15.53,3.0,Male,Yes,Sat,Dinner,2
-10.07,1.25,Male,No,Sat,Dinner,2
-12.6,1.0,Male,Yes,Sat,Dinner,2
-32.83,1.17,Male,Yes,Sat,Dinner,2
-35.83,4.67,Female,No,Sat,Dinner,3
-29.03,5.92,Male,No,Sat,Dinner,3
-27.18,2.0,Female,Yes,Sat,Dinner,2
-22.67,2.0,Male,Yes,Sat,Dinner,2
-17.82,1.75,Male,No,Sat,Dinner,2
-18.78,3.0,Female,No,Thur,Dinner,2

ui/candidate_profile.py

@@ -0,0 +1,41 @@
+from shiny import ui
+
+ui = ui.nav_panel(
+    "Candidate Profile",
+
+    ui.h2("🧑‍💼 Candidate Dashboard"),
+
+    ui.layout_columns(
+
+        # LEFT PANEL: Resume + Job Selection, Scores, Notes
+        ui.card(
+            ui.h4("🎯 Evaluation Controls"),
+            ui.input_select("job_dropdown_for_doc", "Select Job", choices=[]),
+            ui.input_select("candidate_dropdown_for_doc", "Select Candidate", choices=[]),
+
+            ui.tags.hr(),
+            ui.h4("📊 Score Summary"),
+            ui.output_ui("score"),
+
+            ui.tags.hr(),
+            ui.h4("🗒️ Notes & Tags"),
+            ui.output_ui("candidate_note_ui"),
+            ui.output_ui("candidate_tags_ui"),
+            ui.input_action_button("save_note_tags", "💾 Save Notes & Tags"),
+            ui.output_text_verbatim("note_tag_status"),
+            ui.output_text_verbatim("note_preview"),
+
+            col_width=4
+        ),
+        # RIGHT PANEL: LLM Summary
+        ui.card(
+            ui.h4("🧠 Candidate Summary"),
+            ui.div(
+                ui.input_switch('show_gemini', 'Show Gemini', value=False),
+                ui.output_ui("summary"),
+                class_="mt-2"
+            ),
+            col_width=8
+        )
+    )
+)

ui/chart_generation.py

@@ -0,0 +1,56 @@
+from shiny import ui
+
+# ✅ Define the chart tab panel ONCE
+plot_ui = ui.nav_panel(
+    "Chart Generation",  # tab label
+    ui.h2("Visualise Trends Between Chosen Candidate Variables"),
+    ui.layout_columns(
+        ui.card(
+            ui.input_select("chart_job_id", "Select Job ID", choices=[], selected=None),
+            ui.input_select("chart_x", "X-axis variable", choices=[], selected=None),
+            ui.input_select("chart_y", "Y-axis variable", choices=[], selected=None),
+            ui.input_radio_buttons('chart_type', 'Chart Type', choices=['scatter', 'bar', 'line', 'histogram'], selected='scatter'),
+
+
+            ui.div(
+                ui.output_ui("generate_display_plot"),
+                id="plot_wrapper",
+                class_="plot-wrapper",
+                style="padding-top: 1rem; border: 1px solid #ddd; background-color: #fff; width: 100%; overflow-x: auto;"
+            ),
+
+
+            ui.input_action_button("generate_plot", "Generate Chart & Explanation"),
+        ),
+        ui.card(
+            ui.h4("LLM Explanation"),
+            ui.output_ui("llm_explain_plot")
+        ),
+        ui.card(
+            ui.h4("Ask a Follow-up Question"),
+            ui.input_text_area("chart_chat_input", "Ask anything:", rows=2, width="100%"),
+            ui.input_action_button("chart_chat_send", "Send"),
+            ui.h4("Gemini Response"),
+            ui.div(
+                ui.output_ui("chat_followup"),
+                style="""
+                    min-height: 300px;
+                    max-height: 700px;
+                    overflow-y: auto;
+                    resize: vertical;
+                    padding: 1rem;
+                    font-size: 1rem;
+                    border: 1px solid #ccc;
+                    background-color: #fefefe;
+                    box-shadow: 0 0 4px rgba(0,0,0,0.1);
+                """
+            ),
+            class_="response-box",
+            style="""
+                min-height: 600px;
+                width: 100%;
+            """
+        ),
+        col_widths=(5, 5, 5)
+    )
+)

ui/correlation_analysis.py

@@ -0,0 +1,66 @@
+from shiny import ui
+
+ui = ui.nav_panel(
+    "Correlation Explorer",
+
+    # === Global CSS Styling ===
+    ui.tags.style("""
+        .chat-label {
+            font-weight: bold;
+            margin-top: 1em;
+        }
+        .response-box {
+            background-color: #f9f9f9;
+            border: 1px solid #ccc;
+            padding: 1em;
+            border-radius: 8px;
+            margin-top: 1em;
+            max-height: 400px;
+            overflow-y: auto;
+            white-space: normal;
+        }
+        .markdown p {
+            margin: 0.5em 0;
+        }
+    """),
+
+    # === Header ===
+    ui.h2("Correlation Insights from Candidate Data"),
+
+    # === Box 1: Correlation Controls ===
+    ui.card(
+        ui.input_select("job_id", "Select Job ID", choices=[]),
+        ui.input_select("col1", "Column 1", choices=[]),
+        ui.input_select("col2", "Column 2", choices=[]),
+        ui.input_action_button("calc_corr", "Calculate Correlation"),
+        style="margin-bottom: 2em;"
+    ),
+
+    # === Box 2: Gemini Correlation Output ===
+    ui.card(
+        ui.h4("Gemini Correlation Insight"),
+        ui.output_ui("correlation_output"),
+        style="margin-bottom: 2em;"
+    ),
+
+    # === Box 3: Follow-up Chat and LLM Response ===
+    ui.card(
+        ui.h4("Ask a Follow-up Question"),
+        ui.input_text("chat_input", "Your question:", placeholder="e.g. Does this apply to junior candidates?"),
+        ui.input_action_button("chat_send", "Send"),
+        ui.output_text("chat_status_ui"),
+        ui.div(
+            ui.h4("Gemini Response"),
+            ui.output_ui("chat_response"),
+            class_="response-box"
+        ),
+        style="margin-bottom: 2em;"
+    ),
+
+    # === Box 4: Candidate Table Preview ===
+    ui.card(
+        ui.h4("Candidate Data Preview"),
+        ui.output_table("candidate_table", width="100%"),
+        style="margin-bottom: 2em;"
+    )
+)

ui/document_creation.py

@@ -0,0 +1,61 @@
+from shiny import ui
+
+document_creation_ui = ui.nav_panel(
+    "Document Creation",
+    ui.h2("Generate Offer Letter or Contract"),
+
+    ui.layout_columns(
+        # LEFT COLUMN — Form inputs
+        ui.card(
+            ui.input_select("job_dropdown_doc", "Select Job ID", choices=[]),
+            ui.input_select("candidate_dropdown_doc", "Select Resume", choices=[]),
+            ui.input_text("override_compensation", "Override Compensation (optional):", placeholder="$140,000 + equity"),
+            ui.input_text("override_start_date", "Override Start Date (optional):", placeholder="2025-07-01"),
+            ui.input_text_area("override_notes", "Hiring Manager Notes (optional):", rows=3),
+            ui.input_action_button("generate_offer", "✉️ Generate Offer Letter", class_="btn-primary"),
+            ui.input_action_button("generate_contract", "📄 Generate Contract", class_="btn-secondary"),
+        ),
+
+        # RIGHT COLUMN — Results
+        ui.card(
+            ui.h4("Generated Offer Letter"),
+            ui.div(
+                ui.output_text("offer_letter_text"),
+                ui.download_button("download_offer", "📥 Download Offer Letter as PDF"),
+                style="""
+                    border: 1px solid #ccc;
+                    padding: 1.5em;
+                    border-radius: 8px;
+                    background-color: #f9f9f9;
+                    min-height: 200px;
+                    font-size: 1rem;
+                    line-height: 1.6;
+                    max-width: 900px;
+                    margin-top: 1em;
+                    white-space: pre-wrap;
+                    overflow-y: auto;
+                """
+            ),
+            ui.hr(),
+            ui.h4("Generated Contract"),
+            ui.div(
+                ui.output_text("contract_text"),
+                ui.download_button("download_contract", "📥 Download Contract as PDF"),
+                style="""
+                    border: 1px solid #ccc;
+                    padding: 1.5em;
+                    border-radius: 8px;
+                    background-color: #f1f1f1;
+                    min-height: 200px;
+                    font-size: 1rem;
+                    line-height: 1.6;
+                    max-width: 900px;
+                    margin-top: 1em;
+                    white-space: pre-wrap;
+                    overflow-y: auto;
+                """
+            )
+        ),
+        col_widths=(5, 7)
+    )
+)

ui/home.py

@@ -0,0 +1,72 @@
+from shiny import ui
+
+ui = ui.nav_panel(
+    "🏠 Home",
+
+    # Top welcome content
+    ui.card(
+        ui.h2("Welcome to the AI Recruitment Hub"),
+        ui.p("This dashboard helps you manage candidate evaluations, visualize trends, and generate documentation with LLMs."),
+        ui.tags.ul(
+            ui.tags.li("📥 Upload and parse resumes"),
+            ui.tags.li("🔎 Evaluate candidate fit for specific roles"),
+            ui.tags.li("📊 Analyze trends across candidates"),
+            ui.tags.li("🧠 Compare LLM summaries and scores"),
+            ui.tags.li("📝 Generate offer letters and contracts")
+        ),
+        ui.hr(),
+        ui.p("Use the navigation bar above to access each module."),
+        width=12
+    ),
+
+    # Quick-access tool cards
+    ui.layout_columns(
+        ui.card(
+            ui.h4("🚀 Candidate Profile Viewer"),
+            ui.p("Explore individual candidate summaries and scores."),
+            ui.input_action_button("go_to_candidate", "Go to Candidate Profile", class_="btn btn-primary")
+        ),
+        ui.card(
+            ui.h4("📅 Interview Scheduler"),
+            ui.p("Generate Calendly links for interviews."),
+            ui.input_action_button("go_to_scheduler", "Go to Scheduler", class_="btn btn-secondary")
+        ),
+        ui.card(
+            ui.h4("📈 Chart Insights"),
+            ui.p("Plot correlations and visualize trends."),
+            ui.input_action_button("go_to_charts", "Go to Charting", class_="btn btn-info")
+        ),
+        col_widths=(4, 4, 4)
+    ),
+
+    # Resume Upload Section
+    ui.card(
+        ui.h4("📤 Upload Resume & Link to Job"),
+        ui.layout_columns(
+            ui.input_file("resume_file", "Upload Resume", accept=[".pdf", ".docx"]),
+            ui.input_select("job_id_input", "Select Job", choices=[]),  # To be populated by server
+            col_widths=(6, 6)
+        ),
+        ui.div(
+            ui.input_action_button("upload_resume_btn", "Upload & Link", class_="btn btn-success"),
+            ui.output_text_verbatim("upload_result"),
+            class_="d-flex gap-3 align-items-center mt-3"
+        ),
+        width=12
+    ),
+
+    # JS nav handlers
+    ui.tags.script("""
+        document.addEventListener('click', function(e) {
+            if (e.target.id === 'go_to_candidate') {
+                document.querySelector('a[data-value="Candidate Profile"]')?.click();
+            }
+            if (e.target.id === 'go_to_scheduler') {
+                document.querySelector('a[data-value="Interview Scheduler"]')?.click();
+            }
+            if (e.target.id === 'go_to_charts') {
+                document.querySelector('a[data-value="Chart Generation"]')?.click();
+            }
+        });
+    """)
+)

ui/interview_scheduler.py

@@ -0,0 +1,80 @@
+from shiny import ui
+
+interview_scheduler_ui = ui.nav_panel(
+    "Interview Scheduler",
+    ui.h2("Generate Interview Invitations"),
+
+    ui.layout_columns(
+        # LEFT COLUMN — Input controls
+        ui.card(
+            ui.h4("Candidate Selection"),
+            ui.output_ui("name_selector"),
+            ui.input_action_button("generate_links", "✉️ Generate Interview Emails", class_="btn-primary"),
+        ),
+
+        # RIGHT COLUMN — Results and Editing
+        ui.card(
+            ui.h4("Generated Interview Emails"),
+
+            # Output area for hyperlinks + status
+            ui.div(
+                ui.output_ui("output_links_html"),
+                style="""
+                    border: 1px solid #ccc;
+                    padding: 1.5em;
+                    border-radius: 8px;
+                    background-color: #f9f9f9;
+                    min-height: 200px;
+                    font-size: 1rem;
+                    line-height: 1.6;
+                    max-width: 900px;
+                    margin-top: 1em;
+                    white-space: normal;
+                    overflow-wrap: anywhere;
+                """
+            ),
+
+            # ZIP download button
+            ui.download_button("download_emails", "📥 Download All Emails as ZIP"),
+
+            ui.hr(),
+            ui.h4("PDF Preview"),
+            ui.output_ui("pdf_selector"),
+
+            ui.div(
+                ui.output_ui("pdf_preview"),
+                style="""
+                    border: 1px solid #ccc;
+                    padding: 1.5em;
+                    border-radius: 8px;
+                    background-color: #f1f1f1;
+                    min-height: 400px;
+                    max-width: 900px;
+                    margin-top: 1em;
+                    overflow-y: auto;
+                    font-family: Georgia, serif;
+                    font-size: 1rem;
+                    line-height: 1.6;
+                    white-space: normal;
+                """
+            ),
+
+            ui.hr(),
+            ui.h4("Chat to Refine Email"),
+            ui.div(
+                ui.input_text_area("chat_prompt", "Suggest an edit:", rows=3, placeholder="e.g. make it more concise or formal"),
+                ui.input_action_button("submit_chat", "✏️ Apply Change"),
+                style="margin-top: 1em;"
+            ),
+            ui.output_text_verbatim("refined_output"),
+
+            ui.hr(),
+            ui.h4("Edit Email"),
+            ui.input_action_button("toggle_edit", "✏️ Edit This Email"),
+
+            # ✅ Output UI that will be rendered dynamically
+            ui.output_ui("edit_ui_block")
+        ),
+        col_widths=(5, 7)
+    )
+)

ui/job_creation.py

@@ -0,0 +1,43 @@
+from shiny import ui
+
+app_ui = ui.nav_panel(
+    "Job Creation",
+    ui.h2("Generate a Job Description"),
+
+    # Box 1: Prompt Input
+    ui.card(
+        ui.input_text(
+            "user_input",
+            "Enter prompt",
+            placeholder="e.g. Write a job post for a data analyst",
+            width="100%"
+        ),
+        ui.input_action_button("submit_btn", "Submit"),
+        style="margin-bottom: 2em;"
+    ),
+
+    # Box 2: LLM Response
+    ui.card(
+        ui.h4("LLM Response"),
+        ui.output_ui("job_chat_response"),
+        style="""
+            padding: 1.5em;
+            background-color: #f9f9f9;
+            min-height: 400px;
+            font-size: 1rem;
+            line-height: 1.6;
+            border-radius: 8px;
+            border: 1px solid #ccc;
+            white-space: normal;
+            overflow-y: auto;
+            max-width: 800px;
+        """
+    ),
+
+    # Box 3: Save Job + Status
+    ui.card(
+        ui.input_action_button("save_job_btn", "Save Job"),
+        ui.output_text("save_status_ui"),
+        style="margin-top: 2em;"
+    )
+)