AI Job Hunter Pro

intelligent job search assistant with RAG-based semantic matching, automated applications, and data-driven tracking.

intent

use this skill when you want to search for jobs matching your resume, auto-apply to positions, track application status, generate tailored cover letters, or analyze your job search funnel. the skill combines semantic resume-to-job matching with an automated application pipeline and application tracking. trigger it with phrases like "find jobs for me", "match my resume to jobs", "auto-apply", "track my applications", "job search report", or "optimize my resume for this job".

inputs

local files and config:

• user profile: ~/job_profile.json (contains target roles, skills, location, salary expectations, platforms to search)
• resume file: PDF or DOCX format, imported into RAG vector database via setup
• tracker database: local SQLite db storing application history and status

external connections:

• LinkedIn API (OAuth): requires LINKEDIN_API_KEY and LINKEDIN_API_SECRET env vars. scopes: r_liteprofile, r_emailaddress, r_basicprofile. rate limit: 100 requests/hour per app.
• job board APIs (BOSS, Indeed, etc.): API keys in env vars named {PLATFORM}_API_KEY. typical rate limits: 50-200 requests/hour depending on platform.
• cover letter generation: local LLM or OpenAI API (set OPENAI_API_KEY env var if using cloud model). fallback to local template if key missing.

runtime requirements:

• Python 3.8+
• dependencies: see scripts/requirements.txt (includes RAG framework, web scraping, sqlite3, pdf parsing)
• disk space: ~2GB for vector index and application logs

procedure

setup (first-time only)

1. install dependencies:

   • input: {SKILL_DIR} path
   • run pip install -r scripts/requirements.txt
   • output: all Python packages installed and available

2. initialize RAG vector database:

   • input: none
   • run python3 scripts/setup_rag.py --init
   • output: vector index created at ~/.job_hunter/vector_db/

3. create user profile:

   • input: none
   • copy template: cp assets/profile_template.json ~/job_profile.json
   • manually edit ~/job_profile.json with target roles, skills, location, salary floor, preferred platforms
   • output: valid JSON at ~/job_profile.json

4. import resume into RAG:

   • input: resume file path (PDF or DOCX)
   • run python3 scripts/rag_engine.py --import-resume ~/path/to/resume.pdf
   • output: resume text chunked and embedded into vector database; confirmation message printed

workflow 1: smart job search (RAG matching)

1. load user profile:

   • input: ~/job_profile.json
   • read and parse JSON
   • output: dict with user preferences, target roles, skills

2. execute RAG search:

   • input: user profile, min match score threshold (default 0.75), max results (default 20), platform list (default ["linkedin", "boss"])
   • run: python3 scripts/rag_engine.py --mode search --platforms linkedin,boss --min-score 0.75 --max-results 20
   • output: JSON list of job matches with fields: job_id, title, company, url, match_score (0-1), matched_skills (list), missing_skills (list), salary_range (if available)

3. present results to user:

   • input: job matches from step 2
   • sort by match_score descending
   • print table with: rank, title, company, match_score, top 3 matched skills, top 2 missing skills
   • output: ranked list displayed on terminal or UI

4. user selects jobs to apply to:

   • input: user selection (job IDs or "auto-apply all above score X")
   • validate job IDs exist in result set
   • output: list of selected job IDs

workflow 2: auto-apply pipeline

1. validate selected jobs:

   • input: list of selected job IDs from workflow 1 step 4
   • check if job already applied to (query tracker DB)
   • filter out duplicates
   • output: deduplicated job ID list

2. enter dry-run mode for each job:

   • input: job ID
   • run: python3 scripts/apply_pipeline.py --job-id <id> --mode dry-run --generate-cover-letter --optimize-ats
   • output: object with fields: job_id, generated_cover_letter_text, ats_optimized_resume_highlights (list of bullet points), application_fields_to_be_filled (dict)

3. show user review screen:

   • input: dry-run output from step 2
   • display: job title, company, generated cover letter (full text), ATS resume highlights, any red flags or warnings
   • prompt user: "apply to this job? (y/n/skip/edit)"
   • output: user confirmation (yes/no/skip/edit)

4. handle user edits (if requested):

   • input: user edits to cover letter or resume highlights
   • store edits in memory or temp file
   • output: modified cover letter and highlights

5. submit application (if confirmed):

   • input: confirmed job ID, final cover letter, final resume highlights
   • run: python3 scripts/apply_pipeline.py --job-id <id> --mode submit --cover-letter "<text>" --resume-highlights "<text>"
   • output: submission status object with fields: success (bool), timestamp, job_id, confirmation_url (if available), error_message (if failed)

6. log to tracker database:

   • input: submission status
   • run: python3 scripts/tracker.py --log-application --job-id <id> --status "applied" --timestamp <iso_timestamp> --cover_letter_used "<text>"
   • output: database record created; application added to tracker

7. respect rate limits:

   • input: count of applications submitted today
   • check against max_daily_applications (default 20)
   • if reached, stop processing and inform user
   • output: warning message or halt

workflow 3: application tracking

1. request tracking report:

   • input: report type (daily, weekly, all)
   • run: python3 scripts/tracker.py --report <type>
   • output: JSON data with all applications and statuses

2. generate summary:

   • input: tracker JSON from step 1
   • compute: total applied, screening stage count, interview stage count, offer count, rejected count, response rate (%), funnel conversion %, days elapsed per stage
   • output: summary stats printed and saved to ~/.job_hunter/reports/job_search_<date>.json

workflow 4: feedback loop (optional)

1. user provides signal:

   • input: job ID, signal (like or dislike)
   • run: python3 scripts/rag_engine.py --mode feedback --job-id <id> --signal like|dislike
   • output: RAG query vectors adjusted; confirmation message

2. update user preferences (optional):

   • input: feedback signal
   • if dislike: reduce weight of matched skills from that job in future searches
   • if like: increase weight of matched skills from that job
   • output: user profile weights updated

decision points

if user requests dry-run vs. submit:

• if user has not yet confirmed the application, run in --mode dry-run and present cover letter + resume for review.
• if user explicitly confirms ("yes, apply now"), switch to --mode submit.
• if user requests edits, apply edits in memory and re-run --mode dry-run before allowing submit.

if API authentication fails (LinkedIn, job board, or OpenAI):

• if LINKEDIN_API_KEY env var is missing, skip LinkedIn search and only search BOSS and other configured platforms.
• if OPENAI_API_KEY is missing, fall back to local template-based cover letter generation (less personalized).
• if job board API returns 401/403 (auth expired), log error, inform user, and suggest manual re-auth via python3 scripts/setup_rag.py --auth <platform>.

if job board returns rate limit error (429 or similar):

• stop processing queue immediately.
• inform user of remaining daily quota and retry time.
• save queued jobs to ~/.job_hunter/queue_pending.json for later retry.

if RAG match score below threshold but user insists:

• if match_score < 0.75 (default threshold) but user wants to apply anyway, allow override with explicit user confirmation.
• log override in tracker for later analysis.

if resume was never imported:

• if ~/.job_hunter/vector_db/resume_embeddings.pkl does not exist, halt and instruct user to run setup step 4 (import resume).
• output error: "resume not found in vector db. run: python3 scripts/rag_engine.py --import-resume ~/path/to/resume.pdf"

if job already applied to:

• if tracker DB shows application to job_id already logged, skip it and inform user: "already applied to this job on . skipping."
• output: deduplicated list.

if network timeout or platform downtime:

• if any HTTP request times out after 30 seconds, retry up to 2 times with exponential backoff (5s, 10s).
• if all retries fail, log error, report to user, and move to next job in queue.

if job listing has no salary data:

• if salary_range is null or empty, continue processing (salary is optional).
• note in output: "salary not posted".

if result set is empty:

• if RAG search returns 0 results, inform user: "no jobs matched your profile with score >= 0.75. try lowering min-score threshold or broadening target roles."
• output: empty list, no applications attempted.

output contract

success outputs:

1. smart job search (workflow 1): JSON file at ~/.job_hunter/search_results_<timestamp>.json containing array of job objects. each object has: job_id (string), title (string), company (string), url (string), match_score (float 0-1), matched_skills (array of strings), missing_skills (array of strings), salary_range (string or null). minimum 1 job, maximum 20 jobs (or user-specified limit).

2. auto-apply pipeline (workflow 2): for each applied job, append record to ~/.job_hunter/applications.json with fields: job_id, title, company, applied_at (ISO timestamp), cover_letter_used (text), ats_highlights (array), status ("applied"), url. also print to stdout: "applied to [count] job(s). see ~/.job_hunter/applications.json for details."

3. application tracking (workflow 3): JSON report saved to ~/.job_hunter/reports/job_search_<date>.json containing: total_applied (int), stage_breakdown (object with keys discovered/applied/screening/interview/offer/rejected, values are counts), response_rate (float 0-1), funnel_conversion (object mapping stage transitions to %), days_in_stage (object mapping stage to average days), export_date (ISO timestamp). also print summary table to stdout.

4. feedback loop (workflow 4): confirmation message "feedback recorded for job [job_id]. RAG vectors updated." RAG query weights are updated in vector DB (no separate file output needed).

5. error cases: all errors logged to ~/.job_hunter/errors.log with timestamp and error message. user also sees error printed to stdout.

outcome signal

the skill worked if:

• smart job search: user sees a ranked list of jobs sorted by match score, with clear visibility into which skills matched and which are missing. at least one job appears with score >= 0.75.
• auto-apply: user sees dry-run review screen showing generated cover letter and ATS highlights before any submission. after confirmation, application is submitted and a confirmation message appears. application ID and timestamp are logged to tracker.
• application tracking: user receives a report showing their application pipeline with stage counts, response rate, and time-per-stage metrics. report is saved to file and printed to stdout.
• feedback loop: user provides a like/dislike signal and receives confirmation that RAG vectors were updated. future searches reflect the feedback (e.g., if user liked a job, similar jobs rank higher next time).
• no data loss: all resume data, applications, and tracker records remain local. no external uploads occur except to the job platforms themselves during submission.
• rate limits respected: user is never submitted more than 20 applications in a single day. system halts and warns before hitting limit.
• dry-run always first: user never sees an application submitted without explicit confirmation in a review screen.

credits: original author not declared in source material. enriched per implexa quality standards.