added env variables to fastApi for hosting, formatting changes from black

Author: Jared-Krajewski

backend/clients/groq_client.py

@@ -35,7 +35,10 @@ async def optimize_with_groq(resume_text: str, job_description: str, api_key: st
     async with httpx.AsyncClient() as client:
         response = await client.post(
             "https://api.groq.com/openai/v1/chat/completions",
-            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
             json={
                 "model": GROQ_MODEL,
                 "messages": [

backend/clients/ollama_client.py

@@ -15,8 +15,8 @@ def get_ollama_client():
     Returns:
         Configured ollama client
     """
-    ollama_host = os.getenv('OLLAMA_HOST', 'http://localhost:11434')
-    if ollama_host != 'http://localhost:11434':
+    ollama_host = os.getenv("OLLAMA_HOST", "http://localhost:11434")
+    if ollama_host != "http://localhost:11434":
         # Configure ollama client for custom host
         ollama._client.base_url = ollama_host
     return ollama

backend/main.py

@@ -1,4 +1,5 @@
 import logging
+import os
 
 from fastapi import FastAPI, File, HTTPException, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
@@ -17,12 +18,14 @@
 app = FastAPI(title="ATS-Buddy", description="AI-powered resume customizer for job applications")
 
 # Configure CORS for Next.js frontend
+allowed_origins = [
+    os.environ.get("FRONTEND_ORIGIN", "http://localhost:3000"),
+    os.environ.get("NEXT_PUBLIC_API_URL", "http://localhost:8000"),
+]
+
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=[
-        "http://localhost:3000",  # Next.js dev server
-        "http://frontend:3000",  # Docker container
-    ],
+    allow_origins=allowed_origins,
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -66,7 +69,11 @@ async def health_check():
 
         # Test Ollama connection
         models = ollama_client.list()
-        return {"status": "healthy", "ollama_available": True, "available_models": [model.model for model in models.models]}
+        return {
+            "status": "healthy",
+            "ollama_available": True,
+            "available_models": [model.model for model in models.models],
+        }
     except Exception as e:
         logger.error(f"Health check failed: {e}")
         return {"status": "unhealthy", "ollama_available": False, "error": str(e)}
@@ -181,11 +188,17 @@ async def optimize_resume_endpoint(request: ResumeRequest):
         # Step 0: validation:
         # Validate that either job_url or job_description is provided
         if not request.job_url and not request.job_description:
-            raise HTTPException(status_code=400, detail="Either job_url or job_description must be provided")
+            raise HTTPException(
+                status_code=400,
+                detail="Either job_url or job_description must be provided",
+            )
 
         # Validate Groq API key if using Groq
         if request.use_groq and not request.groq_api_key:
-            raise HTTPException(status_code=400, detail="Groq API key is required when use_groq is enabled")
+            raise HTTPException(
+                status_code=400,
+                detail="Groq API key is required when use_groq is enabled",
+            )
 
         # Step 1: Get job description (either from URL or direct input)
         if request.job_description:
@@ -207,7 +220,9 @@ async def optimize_resume_endpoint(request: ResumeRequest):
         logger.info("Successfully optimized resume")
 
         return ResumeResponse(
-            optimized_resume=result["optimized_resume"], job_description=job_description, changes_made=result["changes_made"]
+            optimized_resume=result["optimized_resume"],
+            job_description=job_description,
+            changes_made=result["changes_made"],
         )
 
     except Exception as e:

backend/optimization/change_detector.py

@@ -30,31 +30,31 @@ def detect_changes(original_text: str, optimized_text: str) -> list[str]:
 
     try:
         # Split into lines for comparison
-        original_lines = [line.strip() for line in original_text.split('\n') if line.strip()]
-        optimized_lines = [line.strip() for line in optimized_text.split('\n') if line.strip()]
+        original_lines = [line.strip() for line in original_text.split("\n") if line.strip()]
+        optimized_lines = [line.strip() for line in optimized_text.split("\n") if line.strip()]
 
         logger.debug(f"Detecting changes: {len(original_lines)} original lines vs {len(optimized_lines)} optimized lines")
 
         # Use SequenceMatcher to find differences
         matcher = SequenceMatcher(None, original_lines, optimized_lines)
 
         for tag, i1, i2, j1, j2 in matcher.get_opcodes():
-            if tag == 'equal':
+            if tag == "equal":
                 continue
 
             # Find section context for this change
             current_section, current_subsection = _find_section_context(i1, original_lines)
             section_label = f"{current_section} - {current_subsection}" if current_subsection else current_section
 
-            if tag == 'replace':
+            if tag == "replace":
                 # Lines were changed
                 original_chunk = original_lines[i1:i2]
                 optimized_chunk = optimized_lines[j1:j2]
 
                 change_type = _analyze_change_type(original_chunk, optimized_chunk, current_section)
                 changes.append(f"{section_label}: {change_type}")
 
-            elif tag == 'delete':
+            elif tag == "delete":
                 # Lines were removed
                 deleted_chunk = original_lines[i1:i2]
 
@@ -70,7 +70,7 @@ def detect_changes(original_text: str, optimized_text: str) -> list[str]:
                 else:
                     changes.append(f"{section_label}: Removed {len(deleted_chunk)} less relevant item(s)")
 
-            elif tag == 'insert':
+            elif tag == "insert":
                 # Lines were added
                 added_chunk = optimized_lines[j1:j2]
 
@@ -154,28 +154,28 @@ def _identify_section(line: str) -> str | None:
 
     line_stripped = line.strip()
     line_lower = line_stripped.lower()
-    line_clean = line_stripped.rstrip(':').replace('**', '').replace('*', '').replace('#', '').strip()
+    line_clean = line_stripped.rstrip(":").replace("**", "").replace("*", "").replace("#", "").strip()
 
     # Skip empty lines or lines that are too long to be headers
     if not line_clean or len(line_clean) > 60:
         return None
 
     # Skip bullet points
-    if line_stripped.startswith(('• ', '- ', '* ', '○ ', '▪ ', '― ')):
+    if line_stripped.startswith(("• ", "- ", "* ", "○ ", "▪ ", "― ")):
         return None
 
     # Skip lines with too many commas
-    if line.count(',') > 2:
+    if line.count(",") > 2:
         return None
 
     # Check if it's likely a section header
     is_header = False
 
     if line_stripped.isupper():
         is_header = True
-    elif line_stripped.endswith(':'):
+    elif line_stripped.endswith(":"):
         is_header = True
-    elif '**' in line or line.startswith('#'):
+    elif "**" in line or line.startswith("#"):
         is_header = True
     elif len(line_clean.split()) <= 4 and len(line_clean) < 40:
         if line_clean[0].isupper():
@@ -207,8 +207,8 @@ def _analyze_change_type(original: list[str], optimized: list[str], section: str
     Returns:
         Description of the change
     """
-    original_text = ' '.join(original).lower()
-    optimized_text = ' '.join(optimized).lower()
+    original_text = " ".join(original).lower()
+    optimized_text = " ".join(optimized).lower()
 
     # Extract words for comparison
     original_words = set(original_text.split())
@@ -220,7 +220,7 @@ def _analyze_change_type(original: list[str], optimized: list[str], section: str
     # Get significant additions (filter out common words)
     significant_additions = []
     for w in added_words:
-        cleaned = w.strip('.,;:!?()[]{}"\'-')
+        cleaned = w.strip(".,;:!?()[]{}\"'-")
         if cleaned and cleaned not in COMMON_WORDS and len(cleaned) > 2:
             significant_additions.append(cleaned)
 
@@ -231,9 +231,9 @@ def _analyze_change_type(original: list[str], optimized: list[str], section: str
     added_verbs = [w for w in significant_additions if w.lower() in ACTION_VERBS]
 
     # Provide specific feedback based on section and what was added
-    if section.lower() in ['skills', 'technical skills', 'technologies']:
+    if section.lower() in ["skills", "technical skills", "technologies"]:
         if significant_additions:
-            sample_skills = ', '.join(sorted(list(set(significant_additions))[:5]))
+            sample_skills = ", ".join(sorted(list(set(significant_additions))[:5]))
             return f"Added skills: {sample_skills}"
         elif len(added_words) > len(removed_words):
             return "Enhanced skill list with relevant technologies"
@@ -242,15 +242,15 @@ def _analyze_change_type(original: list[str], optimized: list[str], section: str
     display_limit = 8
     if added_tech:
         total = len(set(added_tech))
-        sample = ', '.join(sorted(list(set(added_tech))[:display_limit]))
+        sample = ", ".join(sorted(list(set(added_tech))[:display_limit]))
         if total > display_limit:
             return f"Added keywords: {sample}, +{total - display_limit} more"
         else:
             return f"Added keywords: {sample}"
 
     elif added_testing:
         total = len(set(added_testing))
-        sample = ', '.join(sorted(list(set(added_testing))[:display_limit]))
+        sample = ", ".join(sorted(list(set(added_testing))[:display_limit]))
         if total > display_limit:
             return f"Added testing keywords: {sample}, +{total - display_limit} more"
         else:
@@ -260,17 +260,16 @@ def _analyze_change_type(original: list[str], optimized: list[str], section: str
         return "Added quantifiable metrics and impact"
 
     elif added_verbs:
-        sample = ', '.join(sorted(list(set(added_verbs))[:3]))
+        sample = ", ".join(sorted(list(set(added_verbs))[:3]))
         return f"Strengthened with action verbs: {sample}"
 
     elif len(significant_additions) > 0:
-
         total = len(set(significant_additions))
         if total <= display_limit:
-            sample = ', '.join(sorted(list(set(significant_additions))))
+            sample = ", ".join(sorted(list(set(significant_additions))))
             return f"Added keywords: {sample}"
         else:
-            sample = ', '.join(sorted(list(set(significant_additions))[:display_limit]))
+            sample = ", ".join(sorted(list(set(significant_additions))[:display_limit]))
             return f"Added keywords: {sample}, +{total - display_limit} more"
     elif len(added_words) > len(removed_words):
         return "Enhanced with additional keywords"
@@ -293,17 +292,17 @@ def _consolidate_changes(changes: list[str]) -> list[str]:
     change_dict: dict[str, list[str]] = {}
 
     for change in changes:
-        if ':' in change:
-            section_label = change.split(':', 1)[0].strip()
-            description = change.split(':', 1)[1].strip()
+        if ":" in change:
+            section_label = change.split(":", 1)[0].strip()
+            description = change.split(":", 1)[1].strip()
 
             if section_label not in change_dict:
                 change_dict[section_label] = []
             change_dict[section_label].append(description)
         else:
-            if 'Other' not in change_dict:
-                change_dict['Other'] = []
-            change_dict['Other'].append(change)
+            if "Other" not in change_dict:
+                change_dict["Other"] = []
+            change_dict["Other"].append(change)
 
     # Format consolidated changes
     grouped_changes = []
@@ -324,17 +323,17 @@ def _consolidate_changes(changes: list[str]) -> list[str]:
                     if any(
                         keyword_type in desc
                         for keyword_type in [
-                            'Added skills:',
-                            'Added keywords:',
-                            'Added tech keywords:',
-                            'Added testing keywords:',
+                            "Added skills:",
+                            "Added keywords:",
+                            "Added tech keywords:",
+                            "Added testing keywords:",
                         ]
                     ):
                         # Extract keywords
-                        parts = desc.split(':', 1)
+                        parts = desc.split(":", 1)
                         if len(parts) > 1:
                             keyword_str = parts[1].strip()
-                            keyword_list = keyword_str.split(',')[:-1] if '+' in keyword_str else keyword_str.split(',')
+                            keyword_list = keyword_str.split(",")[:-1] if "+" in keyword_str else keyword_str.split(",")
                             all_keywords.extend([k.strip() for k in keyword_list if k.strip()])
                     else:
                         other_changes.append(desc)

backend/optimization/response_parser.py

@@ -26,7 +26,7 @@ def parse_llm_response(response_text: str, original_text: str | None = None) ->
         logger.debug(f"Raw response received (first 1000 chars): {response_text[:1000]}")
 
         # Try to find JSON in the response
-        json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
+        json_match = re.search(r"\{.*\}", response_text, re.DOTALL)
 
         if json_match:
             json_str = json_match.group(0)
@@ -42,7 +42,7 @@ def parse_llm_response(response_text: str, original_text: str | None = None) ->
 
             # Check if the optimized_resume field contains embedded JSON
             if isinstance(resume_text, str):
-                if resume_text.strip().startswith('{') and resume_text.strip().endswith('}'):
+                if resume_text.strip().startswith("{") and resume_text.strip().endswith("}"):
                     try:
                         embedded_json = json.loads(resume_text)
                         if "optimized_resume" in embedded_json:
@@ -126,8 +126,8 @@ def _trim_at_markers(text: str) -> str:
         "Modifications:",
         "Key changes:",
         "Updates made:",
-        '},',
-        ']',
+        "},",
+        "]",
     ]
 
     earliest_pos = len(text)
@@ -153,7 +153,7 @@ def _try_regex_extraction(response_text: str, original_text: str | None = None)
     Returns:
         Parsed result or None if extraction fails
     """
-    if not (response_text.strip().startswith('{') and response_text.strip().endswith('}')):
+    if not (response_text.strip().startswith("{") and response_text.strip().endswith("}")):
         return None
 
     # Extract optimized_resume content
@@ -167,7 +167,7 @@ def _try_regex_extraction(response_text: str, original_text: str | None = None)
         return None
 
     resume_content = resume_match.group(1)
-    resume_content = resume_content.replace('\\"', '"').replace('\\n', '\n').replace('\\t', '\t')
+    resume_content = resume_content.replace('\\"', '"').replace("\\n", "\n").replace("\\t", "\t")
     logger.info("Successfully extracted optimized resume using regex parsing")
 
     # Extract changes_made if it exists

backend/optimization/text_cleaner.py

@@ -20,36 +20,36 @@ def clean_resume_text(text: str) -> str:
         return text
 
     # Remove markdown code block syntax (```json, ```, etc.)
-    text = re.sub(r'^```[\w]*\n?', '', text, flags=re.MULTILINE)
-    text = re.sub(r'\n?```$', '', text, flags=re.MULTILINE)
+    text = re.sub(r"^```[\w]*\n?", "", text, flags=re.MULTILINE)
+    text = re.sub(r"\n?```$", "", text, flags=re.MULTILINE)
 
     # Remove triple quotes at start/end (common with Groq responses)
-    text = re.sub(r'^"""\s*\n?', '', text, flags=re.MULTILINE)
-    text = re.sub(r'\n?\s*"""$', '', text, flags=re.MULTILINE)
+    text = re.sub(r'^"""\s*\n?', "", text, flags=re.MULTILINE)
+    text = re.sub(r'\n?\s*"""$', "", text, flags=re.MULTILINE)
 
     # Remove JSON artifacts that might be embedded in the text
     json_artifacts = [
         r'",?\s*\n?\s*"changes_made":\s*\[.*?\].*?}?$',  # Remove changes_made array at end
         r'",?\s*\n?\s*"keyword_matches":\s*\[.*?\].*?}?$',  # Remove keyword_matches array at end
         r'"\s*,\s*\n?\s*"changes_made".*$',  # Remove changes_made key and following content
         r'"\s*,\s*\n?\s*"keyword_matches".*$',  # Remove keyword_matches key and following content
-        r'\]\s*}?\s*$',  # Remove trailing array/object closures
-        r'\n*}$',  # Remove trailing curly brace at end of text
-        r'\n*\}$',  # Remove trailing curly brace with newline
-        r'\n*\}\s*$',  # Remove trailing curly brace with whitespace
+        r"\]\s*}?\s*$",  # Remove trailing array/object closures
+        r"\n*}$",  # Remove trailing curly brace at end of text
+        r"\n*\}$",  # Remove trailing curly brace with newline
+        r"\n*\}\s*$",  # Remove trailing curly brace with whitespace
     ]
 
     for pattern in json_artifacts:
-        text = re.sub(pattern, '', text, flags=re.MULTILINE | re.DOTALL)
+        text = re.sub(pattern, "", text, flags=re.MULTILINE | re.DOTALL)
 
     # Remove any leading '{', quotes, or JSON artifacts at the start
-    text = re.sub(r'^[{\s]*"?optimized_resume"?\s*:\s*"?', '', text)
+    text = re.sub(r'^[{\s]*"?optimized_resume"?\s*:\s*"?', "", text)
     text = text.strip('`"} {')
 
     # Remove extra leading/trailing whitespace while preserving internal formatting
     text = text.strip()
 
     # Normalize line endings and remove excessive blank lines
-    text = re.sub(r'\n{3,}', '\n\n', text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
 
     return text