Upload 6 files

Flowme.md

@@ -0,0 +1,5 @@
+To Run this Application we need the Below Files,
+- app.py
+- requirements.txt
+- writer_prompts.py
+- WRITERS_DESK_PROMPTS.xlsx

README.md

@@ -0,0 +1,14 @@
+---
+title: Al Recruiter Desk V2
+emoji: ⚡
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+sdk_version: 6.14.0
+python_version: '3.13'
+app_file: app.py
+pinned: false
+short_description: AI powered Recruiter and Writer Desk
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,997 @@
+#!/usr/bin/env python3
+import os
+import asyncio
+import logging
+import re
+from typing import Optional, List, Tuple, Dict
+
+from dotenv import load_dotenv
+import gradio as gr
+import google.generativeai as genai
+from openai import AsyncOpenAI
+import fitz  # PyMuPDF
+from docx import Document
+import pandas as pd
+
+from writer_prompts import WRITER_PRESET_LABELS, WRITER_PRESET_MAP
+
+load_dotenv()
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    handlers=[logging.StreamHandler()],
+)
+logger = logging.getLogger("ATSApp")
+
+logger.info("===== Application Startup =====")
+
+
+RECRUITER_USERNAME = os.getenv("RECRUITER_USERNAME") or os.getenv("USERNAME_DualMind")
+RECRUITER_PASSWORD = os.getenv("RECRUITER_PASSWORD") or os.getenv("PASSWORD")
+WRITER_USERNAME = os.getenv("WRITER_USERNAME") or ""
+WRITER_PASSWORD = os.getenv("WRITER_PASSWORD") or ""
+
+WRITER_COMBINED_MAX_CHARS = 300_000
+
+current_task_cancelled = False
+current_task: Optional[asyncio.Task] = None
+
+# -------------------------
+# Helper: Clean & truncate
+# -------------------------
+def clean_text(s: str) -> str:
+    logger.debug("Cleaning text input...")
+    original_len = len(s)
+    s = s.replace("\x00", " ")
+    s = re.sub(r"[ \t]+", " ", s)
+    s = re.sub(r"\n\s*\n\s*\n+", "\n\n", s)
+    cleaned = s.strip()
+    logger.info(f"Text cleaned. Original length={original_len}, Cleaned length={len(cleaned)}")
+    return cleaned
+
+
+def truncate_tokens(plain: str, max_chars: int = WRITER_COMBINED_MAX_CHARS) -> str:
+    logger.debug(f"Checking if truncation required. Length={len(plain)}, Limit={max_chars}")
+    if plain and len(plain) > max_chars:
+        logger.warning(f"Truncating text. Original length={len(plain)} exceeds {max_chars}")
+        return plain[:max_chars] + "\n\n[TRUNCATED]"
+    return plain or ""
+
+
+def _extract_docx_paragraphs_and_tables(path: str) -> str:
+    doc = Document(path)
+    parts: List[str] = []
+    for p in doc.paragraphs:
+        if p.text.strip():
+            parts.append(p.text.strip())
+    for tbl in doc.tables:
+        for row in tbl.rows:
+            cells = [c.text.strip() for c in row.cells]
+            if any(cells):
+                parts.append(" | ".join(cells))
+    return "\n".join(parts)
+
+
+def extract_legacy_doc(path: str) -> Tuple[str, str]:
+    if os.name != "nt":
+        return "error", "Legacy .doc is only supported on Windows with Word and pywin32 installed."
+    try:
+        import win32com.client  # type: ignore
+    except ImportError:
+        return "error", "Legacy .doc requires pywin32 and Microsoft Word. Convert to DOCX instead."
+    path = os.path.abspath(path)
+    word = win32com.client.DispatchEx("Word.Application")
+    word.Visible = False
+    opened = None
+    try:
+        opened = word.Documents.Open(path, ReadOnly=True)
+        text = opened.Content.Text or ""
+        return "doc", text
+    except Exception as e:
+        logger.error(f"Word .doc extraction failed: {e}", exc_info=True)
+        return "error", f".doc error: {e}"
+    finally:
+        try:
+            if opened:
+                opened.Close(False)
+        except Exception:
+            pass
+        try:
+            word.Quit()
+        except Exception:
+            pass
+
+
+def extract_excel(path: str) -> Tuple[str, str]:
+    low = path.lower()
+    kwargs: Dict = {"sheet_name": None, "dtype": str}
+    try:
+        if low.endswith((".xlsx", ".xlsm")):
+            dfs = pd.read_excel(path, engine="openpyxl", **kwargs)
+        elif low.endswith(".xls"):
+            dfs = pd.read_excel(path, engine="xlrd", **kwargs)
+        else:
+            return "error", "Unsupported spreadsheet format."
+    except Exception as e:
+        logger.error(f"Excel read failed: {e}", exc_info=True)
+        return "error", f"Excel error: {e}"
+
+    if not isinstance(dfs, dict):
+        return "error", "Unexpected Excel parse shape."
+
+    chunks: List[str] = []
+    for sheet_name, frame in dfs.items():
+        chunks.append(f"=== Sheet: {sheet_name} ===")
+        chunks.append(frame.fillna("").astype(str).to_csv(index=False))
+
+    text = "\n".join(chunks)
+    logger.info(f"Excel extracted chars={len(text)}")
+    return "excel", text
+
+
+def extract_writer_document(file_path: str) -> Tuple[str, str]:
+    ext = os.path.splitext(file_path)[1].lower()
+    logger.info(f"Extracting Writer desk file: {file_path}")
+
+    if ext == ".pdf":
+        try:
+            doc = fitz.open(file_path)
+            text = "\n".join(page.get_text() for page in doc)
+            return "pdf", text
+        except Exception as e:
+            logger.error(f"PDF error: {e}", exc_info=True)
+            return "error", f"PDF error: {e}"
+
+    if ext == ".docx":
+        try:
+            return "docx", _extract_docx_paragraphs_and_tables(file_path)
+        except Exception as e:
+            logger.error(f"DOCX error: {e}", exc_info=True)
+            return "error", f"DOCX error: {e}"
+
+    if ext == ".doc":
+        return extract_legacy_doc(file_path)
+
+    if ext in (".xlsx", ".xlsm", ".xls"):
+        return extract_excel(file_path)
+
+    logger.warning(f"Unsupported Writer desk format: {ext}")
+    return "error", f"Unsupported extension {ext}: use PDF, DOC, DOCX, XLS, or XLSX."
+
+
+def extract_resume(file_path: str) -> Tuple[str, str]:
+    logger.info(f"Extracting content from file: {file_path}")
+    ext = os.path.splitext(file_path)[1].lower()
+
+    if ext == ".pdf":
+        try:
+            doc = fitz.open(file_path)
+            text = "\n".join(page.get_text() for page in doc)
+            return "pdf", text
+        except Exception as e:
+            logger.error(f"Error extracting PDF: {e}", exc_info=True)
+            return "error", f"PDF error: {e}"
+
+    elif ext == ".docx":
+        try:
+            doc = Document(file_path)
+            text = "\n".join(p.text for p in doc.paragraphs)
+            return "docx", text
+        except Exception as e:
+            logger.error(f"Error extracting DOCX: {e}", exc_info=True)
+            return "error", f"DOCX error: {e}"
+
+    logger.warning(f"Unsupported file format: {ext}")
+    return "error", "Only PDF and DOCX files are supported for this upload."
+
+
+# -------------------------
+# Build Matcher Prompt
+# -------------------------
+def build_matcher_prompt(resume_text: str, jd_text: str) -> str:
+    logger.info("Building ATS matcher prompt")
+    return f"""
+Resume vs Job Description Matcher – "Check Resume with JD" GPT
+Goal:
+To analyze a candidate's resume against a specific job description and deliver a structured, comprehensive comparison.
+Highlight relevance, alignment, missing elements, and strengths. Provide detailed tables and feedback for improvements.
+Prompt Instructions:
+1. Extract Key Criteria from JD:
+   - Identify required and desired skills, qualifications, domain experience, scope of the project, tools, and years of experience.
+   - Note special industry (e.g., healthcare, US government), technical domains (e.g., cloud, data), and methodologies (e.g., Agile, Waterfall).
+2. Extract Key Experience from Resume:
+   - List certifications, domain expertise, scope matching, years of experience per skill, tools used, and roles.
+   - Highlight any experience directly related to government or healthcare projects.
+3. Match Each JD Requirement to Resume Evidence:
+   - Create a detailed table showing:
+     • JD Requirement
+     • Resume Evidence
+     • Estimated Experience
+     • Match Level (Strong, Partial, Missing)
+     • Notes
+4. Summarize Gaps & Suggestions:
+   - Highlight unmatched or weak areas with actionable suggestions.
+   - Suggest language or formatting improvements to better match keywords.
+5. Calculate Matching Score:
+   - Provide a percentage estimate based on number and weight of matched criteria.
+6. Professional Summary:
+   - Offer a polished paragraph summarizing compatibility and recommendation for applying or tailoring further.
+7. Tone:
+   - Use a professional, constructive, and supportive tone focused on improvement and clarity.
+8. You need to show matching score and why this candidate or candidates are suitable for the positions
+   and if not then why they are not suitable for the position.
+### JOB DESCRIPTION
+{jd_text}
+### CANDIDATE RESUMES
+{resume_text}
+"""
+
+
+def build_writer_user_prompt(preset_choice: str, user_custom_prompt: str) -> Tuple[bool, str]:
+    preset_choice = preset_choice or WRITER_PRESET_LABELS[0]
+    preset_body = (WRITER_PRESET_MAP.get(preset_choice) or "").strip()
+    custom = (user_custom_prompt or "").strip()
+
+    if not preset_body and not custom:
+        return False, ""
+
+    chunks: List[str] = []
+    if preset_body:
+        chunks.append(preset_body)
+    if custom:
+        chunks.append("### USER PROMPT\n" + custom)
+
+    return True, "\n\n".join(chunks)
+
+
+class ResumeATSChat:
+    def __init__(self):
+        logger.info("Initializing ResumeATSChat instance")
+        self.setup_apis()
+
+    def setup_apis(self):
+        logger.info("Setting up AI API connections...")
+        self.gemini_available = False
+        self.openai_available = False
+        try:
+            genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+            self.gemini_model = genai.GenerativeModel("gemini-2.5-flash")
+            self.gemini_available = True
+            logger.info("Gemini API configured successfully")
+        except Exception as e:
+            logger.error(f"Gemini setup failed: {e}")
+
+        try:
+            self.openai_client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+            self.openai_available = True
+            logger.info("OpenAI API configured successfully")
+        except Exception as e:
+            logger.error(f"OpenAI setup failed: {e}")
+
+    async def _analyze_with_gemini(self, prompt: str) -> Dict[str, Optional[str]]:
+        global current_task_cancelled
+        if current_task_cancelled:
+            logger.info("Gemini analysis aborted before sending")
+            return {"data": "⚠️ Cancelled"}
+
+        logger.info("Sending prompt to Gemini API")
+        try:
+            gem_raw = await self.gemini_model.generate_content_async(prompt)
+            text = getattr(gem_raw, "text", None) or ""
+            if not text.strip():
+                text = "(Gemini returned an empty reply.)"
+
+            if current_task_cancelled:
+                logger.info("Gemini analysis aborted after response")
+                return {"data": "⚠️ Cancelled"}
+
+            return {"data": text}
+        except Exception as e:
+            logger.error(f"Gemini analysis failed: {e}", exc_info=True)
+            return {"data": f"Gemini error: {e}"}
+
+    async def _analyze_with_openai(self, prompt: str) -> Dict[str, Optional[str]]:
+        global current_task_cancelled
+        if current_task_cancelled:
+            logger.info("OpenAI analysis aborted before sending")
+            return {"data": "⚠️ Cancelled"}
+
+        logger.info("Sending prompt to OpenAI GPT API")
+        try:
+            gpt_raw = await self.openai_client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.2,
+            )
+
+            if current_task_cancelled:
+                logger.info("OpenAI analysis aborted after response")
+                return {"data": "⚠️ Cancelled"}
+
+            content = (
+                gpt_raw.choices[0].message.content if gpt_raw and gpt_raw.choices else ""
+            ) or ""
+            return {"data": content}
+        except Exception as e:
+            logger.error(f"ChatGPT analysis failed: {e}", exc_info=True)
+            return {"data": f"ChatGPT error: {e}"}
+
+    async def _run_dual_llm(self, full_prompt: str) -> Tuple[str, str]:
+        global current_task_cancelled
+        tasks: List = []
+        names: List[str] = []
+        if self.gemini_available:
+            tasks.append(self._analyze_with_gemini(full_prompt))
+            names.append("Gemini")
+        if self.openai_available:
+            tasks.append(self._analyze_with_openai(full_prompt))
+            names.append("ChatGPT")
+
+        if not tasks:
+            logger.error("No AI providers available")
+            return "", "No AI providers are configured. Please set API keys."
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        gemini_resp, chatgpt_resp = "", ""
+        for name, res in zip(names, results):
+            if current_task_cancelled:
+                output_text = "⚠️ Cancelled"
+            elif isinstance(res, Exception):
+                logger.error(f"{name} raised: {res}", exc_info=True)
+                output_text = f"⚠️ {res}"
+            else:
+                output_text = (res.get("data") if isinstance(res, dict) else "") or ""
+                logger.info(f"{name} done. chars={len(output_text)}")
+
+            if name == "Gemini":
+                gemini_resp = output_text or ""
+            elif name == "ChatGPT":
+                chatgpt_resp = output_text or ""
+
+        return chatgpt_resp, gemini_resp
+
+    async def process_multiple(
+        self,
+        jd_message: str,
+        files: Optional[List],
+        prompt_text: Optional[str] = None,
+    ) -> Tuple[str, str]:
+        logger.info("Processing multiple resumes against JD")
+        if not files:
+            return "", "Please upload one or more resumes (PDF/DOCX)."
+
+        combined_resumes: List[str] = []
+        for f in files:
+            global current_task_cancelled
+            if current_task_cancelled:
+                return "⚠️ Cancelled", "⚠️ Cancelled"
+            file_path = f.name if hasattr(f, "name") else str(f)
+            file_type, resume_content = extract_resume(file_path)
+            if file_type == "error":
+                combined_resumes.append(
+                    f"⚠️ Could not extract {os.path.basename(file_path)}: {resume_content}"
+                )
+            else:
+                combined_resumes.append(
+                    f"=== Resume: {os.path.basename(file_path)} ===\n{clean_text(resume_content)}"
+                )
+
+        resume_text = "\n\n".join(combined_resumes)
+        jd_text = clean_text(jd_message)
+
+        if prompt_text and prompt_text.strip():
+            ats_prompt = (
+                f"{prompt_text.strip()}\n\n### JOB DESCRIPTION\n{jd_text}\n\n"
+                f"### CANDIDATE RESUMES\n{resume_text}"
+            )
+        else:
+            ats_prompt = build_matcher_prompt(resume_text, jd_text)
+
+        return await self._run_dual_llm(ats_prompt)
+
+
+# -------------------------
+# JD Extract
+# -------------------------
+def extract_jd(file_path: str) -> str:
+    file_type, text = extract_resume(file_path)
+    if file_type == "error":
+        logger.warning("JD extraction failed")
+        return ""
+    return clean_text(text)
+
+
+# -------------------------
+# Recruiter desk UI (must be built inside root gr.Blocks — no nested Blocks)
+# -------------------------
+def build_recruiter_desk(chat: ResumeATSChat) -> None:
+    logger.info("Creating Recruiter desk UI")
+
+    async def analyze(jd_text, resume_files, jd_file, prompt_text):
+        logger.info("Recruiter: analyze triggered")
+
+        jd_content = ""
+        if jd_file:
+            jd_content = extract_jd(
+                jd_file.name if hasattr(jd_file, "name") else str(jd_file)
+            )
+        elif jd_text:
+            jd_content = clean_text(jd_text)
+
+        if not jd_content:
+            yield (
+                "Please upload or paste a Job Description.",
+                "Please upload or paste a Job Description.",
+            )
+            return
+
+        if not resume_files:
+            yield (
+                "Please upload one or more resumes (PDF/DOCX).",
+                "Please upload one or more resumes (PDF/DOCX).",
+            )
+            return
+
+        yield "Analyzing resumes, please wait...", "Analyzing resumes, please wait..."
+
+        chatgpt_resp, gemini_resp = await chat.process_multiple(
+            jd_content, resume_files, prompt_text
+        )
+        yield chatgpt_resp, gemini_resp
+
+    async def analyze_wrapper(jd_text, resume_files, jd_file, prompt_text):
+        global current_task, current_task_cancelled
+        current_task_cancelled = False
+        current_task = analyze(jd_text, resume_files, jd_file, prompt_text)
+        try:
+            async for result in current_task:
+                if current_task_cancelled:
+                    yield "⚠️ Cancelled", "⚠️ Cancelled"
+                    break
+                yield result
+        except asyncio.CancelledError:
+            yield "⚠️ Cancelled", "⚠️ Cancelled"
+        finally:
+            current_task = None
+
+    async def cancel_analysis():
+        global current_task_cancelled
+        current_task_cancelled = True
+        logger.info("Recruiter: cancel requested")
+        return "⚠️ Cancelled", "⚠️ Cancelled"
+
+    gr.Markdown("## AI Recruiter Desk — JD ↔ Resume Evaluator")
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            jd_text = gr.Textbox(
+                label="Paste Job Description (text)",
+                placeholder="Paste JD here...",
+                lines=10,
+            )
+            prompt_text = gr.Textbox(
+                label="Prompt template override (optional)",
+                placeholder="Optional custom recruiter prompt...",
+                lines=8,
+            )
+        with gr.Column(scale=2):
+            jd_file = gr.File(
+                label="Job Description file (PDF/DOCX)",
+                file_types=[".pdf", ".docx"],
+            )
+            resume_files = gr.File(
+                label="Candidate resumes (PDF/DOCX, multiple)",
+                file_types=[".pdf", ".docx"],
+                file_count="multiple",
+            )
+            with gr.Row():
+                analyze_btn = gr.Button("Analyze", variant="primary")
+                cancel_btn = gr.Button("Cancel", variant="stop")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### ChatGPT")
+            recruiter_chatgpt = gr.Markdown(buttons=["copy"])
+        with gr.Column():
+            gr.Markdown("### Gemini")
+            recruiter_gemini = gr.Markdown(buttons=["copy"])
+
+    analyze_btn.click(
+        analyze_wrapper,
+        inputs=[jd_text, resume_files, jd_file, prompt_text],
+        outputs=[recruiter_chatgpt, recruiter_gemini],
+        show_progress="full",
+    )
+    cancel_btn.click(
+        cancel_analysis,
+        inputs=[],
+        outputs=[recruiter_chatgpt, recruiter_gemini],
+        show_progress="full",
+    )
+
+
+# -------------------------
+# Writer desk UI (must be built inside root gr.Blocks — no nested Blocks)
+# -------------------------
+def build_writer_desk(chat: ResumeATSChat) -> None:
+    logger.info("Creating Writer desk UI")
+
+    async def analyze_writer(preset_choice, user_custom_prompt, uploaded_files):
+        global current_task_cancelled
+        logger.info("Writer: analyze triggered")
+
+        ok_combo, preset_and_custom = build_writer_user_prompt(
+            preset_choice, user_custom_prompt
+        )
+        if not ok_combo:
+            yield (
+                "Select a preset and/or fill the user prompt.",
+                "Select a preset and/or fill the user prompt.",
+                "",
+                "",
+                "",
+                "",
+            )
+            return
+
+        if not uploaded_files:
+            yield (
+                "Upload one or more source files (DOC, DOCX, PDF, XLS, XLSX).",
+                "Upload one or more source files (DOC, DOCX, PDF, XLS, XLSX).",
+                "",
+                "",
+                "",
+                "",
+            )
+            return
+
+        yield "Running Writer desk analysis...", "Running Writer desk analysis...", "", "", "", ""
+
+        doc_chunks: List[str] = []
+        for f in uploaded_files:
+            if current_task_cancelled:
+                yield "⚠️ Cancelled", "⚠️ Cancelled"
+                return
+            file_path = f.name if hasattr(f, "name") else str(f)
+            kind, content = extract_writer_document(file_path)
+            base = os.path.basename(file_path)
+            if kind == "error":
+                doc_chunks.append(f"=== File: {base} ===\n{content}")
+            else:
+                doc_chunks.append(f"=== File: {base} ({kind}) ===\n{clean_text(content)}")
+
+        documents_blob = "\n\n".join(doc_chunks)
+        final_prompt = truncate_tokens(
+            f"{preset_and_custom}\n\n### UPLOADED SOURCE DOCUMENTS\n{documents_blob}",
+            max_chars=WRITER_COMBINED_MAX_CHARS,
+        )
+
+        chatgpt_resp, gemini_resp = await chat._run_dual_llm(final_prompt)
+        yield (
+            chatgpt_resp,
+            gemini_resp,
+            preset_and_custom,
+            documents_blob,
+            chatgpt_resp,
+            gemini_resp,
+        )
+
+    async def analyze_writer_wrapper(preset_choice, user_custom_prompt, uploaded_files):
+        global current_task, current_task_cancelled
+        current_task_cancelled = False
+        current_task = analyze_writer(preset_choice, user_custom_prompt, uploaded_files)
+        try:
+            async for chunk in current_task:
+                if current_task_cancelled:
+                    yield "⚠️ Cancelled", "⚠️ Cancelled", "", "", "", ""
+                    break
+                yield chunk
+        except asyncio.CancelledError:
+            yield "⚠️ Cancelled", "⚠️ Cancelled", "", "", "", ""
+        finally:
+            current_task = None
+
+    async def cancel_writer(
+        base_prompt_memory, documents_memory, chatgpt_memory, gemini_memory
+    ):
+        global current_task_cancelled
+        current_task_cancelled = True
+        logger.info("Writer: cancel requested")
+        return (
+            "⚠️ Cancelled",
+            "⚠️ Cancelled",
+            base_prompt_memory,
+            documents_memory,
+            chatgpt_memory,
+            gemini_memory,
+        )
+
+    def _followup_action_instruction(action: str) -> str:
+        action = (action or "").strip()
+        if action == "Continue":
+            return (
+                "Continue from where the prior answer stopped. Do not restart from the beginning. "
+                "Preserve section numbering and structure, and complete all missing remaining sections."
+            )
+        if action == "Reformat":
+            return (
+                "Reformat the answer to be rigid and consistent. Use clear headings, stable section order, "
+                "and markdown tables where applicable. Keep all factual content grounded in source docs."
+            )
+        if action == "Fill Missing Fields":
+            return (
+                "Fill only missing, incomplete, or placeholder fields. Keep completed fields unchanged. "
+                "For unknown items, explicitly write 'Not specified in documents' and cite source location if available."
+            )
+        if action == "Cite Sources":
+            return (
+                "Provide explicit source citations for each claim or table row using file name and page/section/sheet "
+                "where possible. If unavailable, mark citation as 'Source not identifiable from extracted text'."
+            )
+        return "Improve and complete the response based on the follow-up request."
+
+    async def run_writer_followup(
+        target_model,
+        action_choice,
+        followup_instruction,
+        base_prompt_memory,
+        documents_memory,
+        chatgpt_memory,
+        gemini_memory,
+    ):
+        global current_task_cancelled
+        current_task_cancelled = False
+
+        if not (base_prompt_memory and documents_memory):
+            return (
+                "Run Analyze first so follow-up has context memory.",
+                "Run Analyze first so follow-up has context memory.",
+                base_prompt_memory,
+                documents_memory,
+                chatgpt_memory,
+                gemini_memory,
+            )
+
+        if not ((followup_instruction or "").strip() or (action_choice or "").strip()):
+            return (
+                "Choose a follow-up action and/or add instructions.",
+                "Choose a follow-up action and/or add instructions.",
+                base_prompt_memory,
+                documents_memory,
+                chatgpt_memory,
+                gemini_memory,
+            )
+
+        action_directive = _followup_action_instruction(action_choice)
+        custom_followup = (followup_instruction or "").strip()
+
+        def build_model_followup_prompt(model_name: str, model_previous_output: str) -> str:
+            return truncate_tokens(
+                (
+                    "You are refining your own prior Writer Desk output.\n\n"
+                    f"### MODEL\n{model_name}\n\n"
+                    "### ORIGINAL INSTRUCTIONS\n"
+                    f"{base_prompt_memory}\n\n"
+                    "### ORIGINAL SOURCE DOCUMENTS\n"
+                    f"{documents_memory}\n\n"
+                    "### YOUR PREVIOUS OUTPUT\n"
+                    f"{model_previous_output or '(none)'}\n\n"
+                    "### TARGET FOLLOW-UP ACTION\n"
+                    f"{action_choice or 'General follow-up'}\n\n"
+                    "### ACTION DIRECTIVE\n"
+                    f"{action_directive}\n\n"
+                    "### USER FOLLOW-UP INSTRUCTION\n"
+                    f"{custom_followup or '(none)'}\n\n"
+                    "### RESPONSE RULES\n"
+                    "- Return a complete, standalone response (not partial notes).\n"
+                    "- Do not summarize unless explicitly requested.\n"
+                    "- Preserve factual grounding to uploaded documents only.\n"
+                    "- If information is missing, state 'Not specified in documents'.\n"
+                ),
+                max_chars=WRITER_COMBINED_MAX_CHARS,
+            )
+
+        chatgpt_resp = chatgpt_memory or ""
+        gemini_resp = gemini_memory or ""
+        target = (target_model or "").strip()
+
+        if target == "ChatGPT":
+            if not chat.openai_available:
+                chatgpt_resp = "ChatGPT provider unavailable."
+            else:
+                chatgpt_prompt = build_model_followup_prompt("ChatGPT", chatgpt_memory)
+                res = await chat._analyze_with_openai(chatgpt_prompt)
+                chatgpt_resp = (res.get("data") if isinstance(res, dict) else "") or ""
+        elif target == "Gemini":
+            if not chat.gemini_available:
+                gemini_resp = "Gemini provider unavailable."
+            else:
+                gemini_prompt = build_model_followup_prompt("Gemini", gemini_memory)
+                res = await chat._analyze_with_gemini(gemini_prompt)
+                gemini_resp = (res.get("data") if isinstance(res, dict) else "") or ""
+        else:
+            return (
+                "Invalid follow-up target model.",
+                "Invalid follow-up target model.",
+                base_prompt_memory,
+                documents_memory,
+                chatgpt_memory,
+                gemini_memory,
+            )
+
+        return (
+            chatgpt_resp,
+            gemini_resp,
+            base_prompt_memory,
+            documents_memory,
+            chatgpt_resp,
+            gemini_resp,
+        )
+
+    preset_default = (
+        WRITER_PRESET_LABELS[1]
+        if len(WRITER_PRESET_LABELS) > 1
+        else WRITER_PRESET_LABELS[0]
+    )
+
+    gr.Markdown("## AI Writer Desk — presets + uploads")
+
+    preset_choice = gr.Dropdown(
+        choices=list(WRITER_PRESET_LABELS),
+        value=preset_default,
+        label="Prompt preset",
+    )
+    user_custom_prompt = gr.Textbox(
+        label="Additional / full custom prompt",
+        placeholder="Add instructions here, or use “(none — use user prompt below only)” and paste a full prompt.",
+        lines=12,
+    )
+    uploaded_files = gr.File(
+        label="Source documents (DOC, DOCX, PDF, XLS, XLSX — multiple allowed)",
+        file_types=[".doc", ".docx", ".pdf", ".xls", ".xlsx", ".xlsm"],
+        file_count="multiple",
+    )
+    with gr.Row():
+        go_btn = gr.Button("Analyze", variant="primary")
+        stop_btn = gr.Button("Cancel", variant="stop")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### ChatGPT")
+            writer_chatgpt = gr.Markdown(buttons=["copy"])
+        with gr.Column():
+            gr.Markdown("### Gemini")
+            writer_gemini = gr.Markdown(buttons=["copy"])
+
+    gr.Markdown("### Follow-up refinement (stateful, per model)")
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("#### ChatGPT follow-up")
+            chatgpt_followup_action = gr.Dropdown(
+                choices=["Continue", "Reformat", "Fill Missing Fields", "Cite Sources"],
+                value="Continue",
+                label="ChatGPT follow-up action",
+            )
+            chatgpt_followup_instruction = gr.Textbox(
+                label="ChatGPT follow-up instruction",
+                placeholder="Example: Continue from row 57 onward and keep strict markdown table format.",
+                lines=4,
+            )
+            chatgpt_followup_btn = gr.Button("Run ChatGPT Follow-up", variant="secondary")
+        with gr.Column():
+            gr.Markdown("#### Gemini follow-up")
+            gemini_followup_action = gr.Dropdown(
+                choices=["Continue", "Reformat", "Fill Missing Fields", "Cite Sources"],
+                value="Continue",
+                label="Gemini follow-up action",
+            )
+            gemini_followup_instruction = gr.Textbox(
+                label="Gemini follow-up instruction",
+                placeholder="Example: Reformat output into strict markdown tables with citations.",
+                lines=4,
+            )
+            gemini_followup_btn = gr.Button("Run Gemini Follow-up", variant="secondary")
+
+    writer_base_prompt_memory = gr.State("")
+    writer_documents_memory = gr.State("")
+    writer_chatgpt_memory = gr.State("")
+    writer_gemini_memory = gr.State("")
+    followup_target_chatgpt = gr.State("ChatGPT")
+    followup_target_gemini = gr.State("Gemini")
+
+    go_btn.click(
+        analyze_writer_wrapper,
+        inputs=[preset_choice, user_custom_prompt, uploaded_files],
+        outputs=[
+            writer_chatgpt,
+            writer_gemini,
+            writer_base_prompt_memory,
+            writer_documents_memory,
+            writer_chatgpt_memory,
+            writer_gemini_memory,
+        ],
+        show_progress="full",
+    )
+    stop_btn.click(
+        cancel_writer,
+        inputs=[
+            writer_base_prompt_memory,
+            writer_documents_memory,
+            writer_chatgpt_memory,
+            writer_gemini_memory,
+        ],
+        outputs=[
+            writer_chatgpt,
+            writer_gemini,
+            writer_base_prompt_memory,
+            writer_documents_memory,
+            writer_chatgpt_memory,
+            writer_gemini_memory,
+        ],
+        show_progress="full",
+    )
+    chatgpt_followup_btn.click(
+        run_writer_followup,
+        inputs=[
+            followup_target_chatgpt,
+            chatgpt_followup_action,
+            chatgpt_followup_instruction,
+            writer_base_prompt_memory,
+            writer_documents_memory,
+            writer_chatgpt_memory,
+            writer_gemini_memory,
+        ],
+        outputs=[
+            writer_chatgpt,
+            writer_gemini,
+            writer_base_prompt_memory,
+            writer_documents_memory,
+            writer_chatgpt_memory,
+            writer_gemini_memory,
+        ],
+        show_progress="full",
+    )
+    gemini_followup_btn.click(
+        run_writer_followup,
+        inputs=[
+            followup_target_gemini,
+            gemini_followup_action,
+            gemini_followup_instruction,
+            writer_base_prompt_memory,
+            writer_documents_memory,
+            writer_chatgpt_memory,
+            writer_gemini_memory,
+        ],
+        outputs=[
+            writer_chatgpt,
+            writer_gemini,
+            writer_base_prompt_memory,
+            writer_documents_memory,
+            writer_chatgpt_memory,
+            writer_gemini_memory,
+        ],
+        show_progress="full",
+    )
+
+
+# -------------------------
+# Login shell
+# -------------------------
+def create_app_with_login():
+    logger.info("Creating landing + dual-login")
+    llm_bridge = ResumeATSChat()
+
+    demo = gr.Blocks(title="DualMind AI Desks")
+
+    with demo:
+        gr.Markdown("# DualMind AI Desks")
+        # One login column + one workspace column (avoid toggling multiple top-level
+        # Columns; Gradio's client can leave a blank main area after desk switches.)
+        login_ui = gr.Column(visible=True)
+        post_login = gr.Column(visible=False)
+
+        with login_ui:
+            gr.Markdown("## Desk login")
+            desk_choice = gr.Radio(
+                choices=["AI Recruiter Desk", "AI Writer Desk"],
+                label="Choose desk",
+                value="AI Recruiter Desk",
+            )
+            username = gr.Textbox(label="Username")
+            password = gr.Textbox(label="Password", type="password")
+            login_button = gr.Button("Login", variant="primary")
+            login_status = gr.Markdown()
+
+        with post_login:
+            back_btn = gr.Button("← Back to login", variant="secondary")
+            recruiter_only = gr.Column(visible=False)
+            writer_only = gr.Column(visible=False)
+            with recruiter_only:
+                build_recruiter_desk(llm_bridge)
+            with writer_only:
+                build_writer_desk(llm_bridge)
+
+        shell_outputs = [
+            login_ui,
+            post_login,
+            recruiter_only,
+            writer_only,
+            login_status,
+        ]
+
+        def go_to_login():
+            global current_task_cancelled
+            current_task_cancelled = True
+            t = current_task
+            if t is not None and isinstance(t, asyncio.Task) and not t.done():
+                t.cancel()
+            logger.info("User returned to login screen")
+            return (
+                gr.update(visible=True),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                "Signed out. Choose a desk and sign in again.",
+            )
+
+        def handle_login(desk_name: str, user: str, pw: str):
+            logger.info(f"Login attempt for desk={desk_name} user={user!r}")
+            recruiter_ok = user == RECRUITER_USERNAME and pw == RECRUITER_PASSWORD
+            writer_ok = user == WRITER_USERNAME and pw == WRITER_PASSWORD
+
+            hidden_inner = (gr.update(visible=False), gr.update(visible=False))
+
+            if desk_name == "AI Recruiter Desk" and recruiter_ok:
+                logger.info("Recruiter login OK")
+                return (
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                    gr.update(visible=True),
+                    gr.update(visible=False),
+                    "Login successful.",
+                )
+            if desk_name == "AI Writer Desk" and writer_ok:
+                logger.info("Writer login OK")
+                return (
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                    "Login successful.",
+                )
+
+            logger.warning("Login failed")
+            return (
+                gr.update(visible=True),
+                gr.update(visible=False),
+                hidden_inner[0],
+                hidden_inner[1],
+                "Invalid credentials or wrong desk.",
+            )
+
+        login_button.click(
+            handle_login,
+            inputs=[desk_choice, username, password],
+            outputs=shell_outputs,
+        )
+
+        # Full reload clears a Gradio client bug where the main area stays blank
+        # after logging out of one desk and into another.
+        back_btn.click(
+            go_to_login,
+            inputs=[],
+            outputs=shell_outputs,
+            js="() => setTimeout(() => window.location.reload(), 400)",
+        )
+
+    demo.queue()
+    return demo
+
+
+if __name__ == "__main__":
+    logger.info("Launching Gradio server with login...")
+    demo = create_app_with_login()
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=True, debug=True)
+    logger.info("===== Application Shutdown =====")

requirements.txt

@@ -0,0 +1,12 @@
+gradio>=4.29.0
+pillow>=10.0.0
+pymupdf>=1.23.5
+python-docx>=1.0.1
+pandas>=2.2.2
+openpyxl>=3.1.2
+xlrd>=2.0.1
+google-generativeai>=0.5.4
+openai>=1.30.1
+python-dotenv>=1.0.1
+markdown==3.10.1
+pywin32>=306; sys_platform == "win32"

writer_prompts.py

@@ -0,0 +1,59 @@
+"""Writer Desk presets loaded from WRITERS_DESK_PROMPTS.xlsx (edit Excel to add/remove prompts)."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Dict, Tuple
+
+import pandas as pd
+
+logger = logging.getLogger("ATSApp")
+
+PROMPTS_XLSX = Path(__file__).resolve().parent / "WRITERS_DESK_PROMPTS.xlsx"
+NONE_PRESET_LABEL = "(none — use user prompt below only)"
+
+_TITLE_COL = "Prompt_Title"
+_CONTENT_COL = "Prompt_Content"
+
+
+def load_writer_presets_from_excel(
+    xlsx_path: Path | None = None,
+) -> Tuple[Tuple[str, ...], Dict[str, str]]:
+    path = xlsx_path or PROMPTS_XLSX
+    preset_map: Dict[str, str] = {NONE_PRESET_LABEL: ""}
+
+    if not path.is_file():
+        logger.error("Writer presets Excel not found: %s", path)
+        return (NONE_PRESET_LABEL,), preset_map
+
+    try:
+        df = pd.read_excel(path, engine="openpyxl")
+    except Exception as e:
+        logger.error("Failed to read Writer presets Excel %s: %s", path, e, exc_info=True)
+        return (NONE_PRESET_LABEL,), preset_map
+
+    if _TITLE_COL not in df.columns or _CONTENT_COL not in df.columns:
+        logger.error(
+            "Writer presets Excel must have columns %r and %r; got %s",
+            _TITLE_COL,
+            _CONTENT_COL,
+            list(df.columns),
+        )
+        return (NONE_PRESET_LABEL,), preset_map
+
+    labels: list[str] = [NONE_PRESET_LABEL]
+    for _, row in df.iterrows():
+        title = str(row[_TITLE_COL]).strip()
+        if not title or title in preset_map:
+            continue
+        content = row[_CONTENT_COL]
+        body = "" if pd.isna(content) else str(content).strip()
+        preset_map[title] = body
+        labels.append(title)
+
+    logger.info("Loaded %d Writer desk preset(s) from %s", len(labels) - 1, path.name)
+    return tuple(labels), preset_map
+
+
+WRITER_PRESET_LABELS, WRITER_PRESET_MAP = load_writer_presets_from_excel()