divapply 0.4.2__py3-none-any.whl

divapply/config/searches.example.yaml

@@ -0,0 +1,113 @@
+# DivApply search configuration
+# Copy to ~/.divapply/searches.yaml and customize for your job search.
+# The wizard (divapply init) generates a basic version automatically.
+
+# Search queries -- each has a query string and priority tier.
+# Tier 1: High-priority exact matches (searched first, highest precision)
+# Tier 2: Strong matches, broader scope
+# Tier 3: Wide net, high volume, lower precision
+queries:
+  - query: "software engineer"
+    tier: 1
+  - query: "backend engineer"
+    tier: 1
+  - query: "backend developer"
+    tier: 1
+  - query: "full stack developer"
+    tier: 2
+  - query: "full stack engineer"
+    tier: 2
+  - query: "python developer"
+    tier: 2
+  - query: "python engineer"
+    tier: 2
+  - query: "DevOps engineer"
+    tier: 2
+  - query: "site reliability engineer"
+    tier: 2
+  - query: "platform engineer"
+    tier: 2
+  - query: "cloud engineer"
+    tier: 2
+  - query: "data engineer"
+    tier: 2
+  - query: "infrastructure engineer"
+    tier: 2
+  - query: "software developer"
+    tier: 3
+  - query: "developer"
+    tier: 3
+  - query: "systems engineer"
+    tier: 3
+  - query: "automation engineer"
+    tier: 3
+  - query: "solutions engineer"
+    tier: 3
+  - query: "integration engineer"
+    tier: 3
+  - query: "ML engineer"
+    tier: 3
+  - query: "machine learning engineer"
+    tier: 3
+  - query: "AI engineer"
+    tier: 3
+  - query: "security engineer"
+    tier: 3
+
+# Locations to search
+locations:
+  - location: "San Francisco, CA"
+    remote: false
+  - location: "Remote"
+    remote: true
+
+# Location filtering -- accept/reject patterns for job location text
+location:
+  accept_patterns:
+    - "San Francisco"
+    - "Bay Area"
+    - "SF"
+    - "California"
+    - "CA"
+    - "Remote"
+    - "Anywhere"
+    - "United States"
+    - "US"
+    - "USA"
+  reject_patterns:
+    - "New York only"
+    - "Seattle only"
+    - "onsite only"
+    - "London, UK"
+    - "India"
+    - "Philippines"
+
+# Country for Indeed/LinkedIn/Google Jobs searches
+country: "USA"
+
+# JobSpy source boards (all available options shown)
+boards:
+  - indeed
+  - linkedin
+  - glassdoor
+  - zip_recruiter
+  - google
+
+# Search defaults
+defaults:
+  results_per_site: 100  # Max results per board per query
+  hours_old: 72          # Only jobs posted within this many hours
+
+# Negative keywords -- skip jobs with these in the title (case-insensitive)
+exclude_titles:
+  - "senior director"
+  - "VP "
+  - "vice president"
+  - "chief"
+  - "intern"
+  - "internship"
+  - "co-op"
+  - "clearance required"
+  - "TS/SCI"
+  - "principal scientist"
+

divapply/config/sites.yaml

@@ -0,0 +1,107 @@
+# Direct career site registry for DivApply — Sacramento government focus
+# Dalton De Arrieta: IT support, admin, procurement, fiscal roles
+# All remote developer boards removed — not relevant to this candidate's profile.
+
+# ── Manual-Only ATS Domains ──────────────────────────────────────────────
+# These ATS platforms have unsolvable CAPTCHAs. Jobs routing through them
+# are flagged as "manual" during apply — bot skips, user applies by hand.
+manual_ats:
+  - "ibegin.tcsapps.com"       # TCS iBegin — unsolvable CAPTCHA every time
+
+# ── Blocked sites — too problematic for automation ───────────────────────
+blocked:
+  sites:
+    - "glassdoor"
+    - "google"
+  url_patterns:
+    - "%glassdoor%"
+    - "%google.com/about/careers%"
+    - "%google.jobs%"
+
+# ── Blocked SSO domains — cannot authenticate through these ──────────────
+blocked_sso:
+  - "login.microsoftonline.com"
+  - "okta.com"
+  - "auth0.com"
+
+# ── Base URLs for URL resolution ─────────────────────────────────────────
+base_urls:
+  "GovernmentJobs.com": "https://www.governmentjobs.com"
+#  "City of Roseville": "https://www.governmentjobs.com"
+#  "Placer County": "https://www.jobapscloud.com"
+#  "Sacramento County": "https://www.governmentjobs.com"
+#  "Nevada County": "https://www.governmentjobs.com"
+#  "City of Sacramento": "https://www.governmentjobs.com"
+#  "City of Folsom": "https://www.governmentjobs.com"
+#  "City of Elk Grove": "https://www.governmentjobs.com"
+#  "City of Rocklin": "https://www.governmentjobs.com"
+#  "City of Citrus Heights": "https://www.governmentjobs.com"
+#  "City of Rancho Cordova": "https://www.governmentjobs.com"
+#  "City of Auburn": "https://www.governmentjobs.com"
+#  "CalCareers": "https://calcareers.ca.gov"
+  "SimplyHired": "https://www.simplyhired.com"
+
+sites:
+  # ── GovernmentJobs.com (NEOGOV) — used by nearly all CA government agencies ──
+  # Search type: expands per query × location combo from searches.yaml
+#  - name: "GovernmentJobs.com"
+#    url: "https://www.governmentjobs.com/jobs?keyword={query_encoded}&location={location_encoded}&radius=30"
+#    type: search
+
+  # ── General job search with location ─────────────────────────────────────
+  - name: "SimplyHired"
+    url: "https://www.simplyhired.com/search?q={query_encoded}&l={location_encoded}"
+    type: search
+
+  # ── Static agency pages — Sacramento region government portals ────────────
+  # These are scraped once (no query/location params) and filtered by keyword.
+
+#  - name: "City of Roseville"
+#    url: "https://www.governmentjobs.com/careers/rosevilleca"
+#    type: static
+#
+#  - name: "Placer County"
+#    url: "https://www.jobapscloud.com/Placer/JobBoard.asp"
+#    type: static
+#
+#  - name: "Sacramento County"
+#    url: "https://www.governmentjobs.com/careers/sacramento"
+#    type: static
+#
+#  - name: "City of Sacramento"
+#    url: "https://www.governmentjobs.com/careers/saccity"
+#    type: static
+#
+#  - name: "City of Folsom"
+#    url: "https://www.governmentjobs.com/careers/folsom"
+#    type: static
+#
+#  - name: "City of Elk Grove"
+#    url: "https://www.governmentjobs.com/careers/elkgrove"
+#    type: static
+#
+#  - name: "City of Rocklin"
+#    url: "https://www.governmentjobs.com/careers/rocklinca"
+#    type: static
+#
+#  - name: "City of Citrus Heights"
+#    url: "https://www.governmentjobs.com/careers/citrusheights"
+#    type: static
+#
+#  - name: "City of Rancho Cordova"
+#    url: "https://www.governmentjobs.com/careers/ranchocordova"
+#    type: static
+#
+#  - name: "Nevada County"
+#    url: "https://www.governmentjobs.com/careers/mynevadacounty"
+#    type: static
+#
+#  - name: "City of Auburn"
+#    url: "https://www.governmentjobs.com/careers/auburn"
+#    type: static
+#
+#  # City of Lincoln uses CalOpps (not NEOGOV) — not compatible with this scraper
+#
+#  - name: "CalCareers"
+#    url: "https://calcareers.ca.gov/CalHRPublic/Search/JobSearchResults.aspx"
+#    type: static

divapply/config.py

@@ -0,0 +1,445 @@
+"""DivApply configuration: paths, platform detection, user data."""
+
+import os
+import platform
+import shutil
+from pathlib import Path
+
+# User data directory - all user-specific files live here.
+#
+# New installs default to ~/.divapply, but we still read legacy ~/.applypilot
+# files so existing users can migrate without losing data.
+APP_DIR = Path(os.environ.get("DIVAPPLY_DIR", os.environ.get("APPLYPILOT_DIR", Path.home() / ".divapply")))
+LEGACY_APP_DIR = Path(os.environ.get("APPLYPILOT_DIR", Path.home() / ".applypilot"))
+
+# Core paths
+DB_PATH = APP_DIR / "divapply.db"
+PROFILE_PATH = APP_DIR / "profile.json"
+RESUME_PATH = APP_DIR / "resume.txt"
+RESUME_PDF_PATH = APP_DIR / "resume.pdf"
+SEARCH_CONFIG_PATH = APP_DIR / "searches.yaml"
+ENV_PATH = APP_DIR / ".env"
+LEGACY_DB_PATH = LEGACY_APP_DIR / "applypilot.db"
+LEGACY_PROFILE_PATH = LEGACY_APP_DIR / "profile.json"
+LEGACY_SEARCH_CONFIG_PATH = LEGACY_APP_DIR / "searches.yaml"
+LEGACY_ENV_PATH = LEGACY_APP_DIR / ".env"
+
+# Generated output
+TAILORED_DIR = APP_DIR / "tailored_resumes"
+COVER_LETTER_DIR = APP_DIR / "cover_letters"
+LOG_DIR = APP_DIR / "logs"
+
+# Chrome worker isolation
+CHROME_WORKER_DIR = APP_DIR / "chrome-workers"
+APPLY_WORKER_DIR = APP_DIR / "apply-workers"
+
+# Package-shipped config (YAML registries)
+PACKAGE_DIR = Path(__file__).parent
+CONFIG_DIR = PACKAGE_DIR / "config"
+
+
+def get_chrome_path() -> str:
+    """Auto-detect Chrome/Chromium executable path, cross-platform.
+
+    Override with CHROME_PATH environment variable.
+    """
+    env_path = os.environ.get("CHROME_PATH")
+    if env_path and Path(env_path).exists():
+        return env_path
+
+    system = platform.system()
+
+    if system == "Windows":
+        candidates = [
+            Path(os.environ.get("PROGRAMFILES", r"C:\Program Files")) / "Google/Chrome/Application/chrome.exe",
+            Path(os.environ.get("PROGRAMFILES(X86)", r"C:\Program Files (x86)")) / "Google/Chrome/Application/chrome.exe",
+            Path(os.environ.get("LOCALAPPDATA", "")) / "Google/Chrome/Application/chrome.exe",
+        ]
+    elif system == "Darwin":
+        candidates = [
+            Path("/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
+            Path("/Applications/Chromium.app/Contents/MacOS/Chromium"),
+        ]
+    else:
+        candidates = []
+        for name in ("google-chrome", "google-chrome-stable", "chromium-browser", "chromium"):
+            found = shutil.which(name)
+            if found:
+                candidates.append(Path(found))
+
+    for candidate in candidates:
+        if candidate and candidate.exists():
+            return str(candidate)
+
+    for name in ("google-chrome", "google-chrome-stable", "chromium-browser", "chromium", "chrome"):
+        found = shutil.which(name)
+        if found:
+            return found
+
+    raise FileNotFoundError(
+        "Chrome/Chromium not found. Install Chrome or set CHROME_PATH environment variable."
+    )
+
+
+def get_chrome_user_data() -> Path:
+    """Default Chrome user data directory, cross-platform."""
+    system = platform.system()
+    if system == "Windows":
+        return Path(os.environ.get("LOCALAPPDATA", "")) / "Google" / "Chrome" / "User Data"
+    if system == "Darwin":
+        return Path.home() / "Library" / "Application Support" / "Google" / "Chrome"
+    return Path.home() / ".config" / "google-chrome"
+
+
+def ensure_dirs() -> None:
+    """Create all required directories."""
+    for directory in [APP_DIR, TAILORED_DIR, COVER_LETTER_DIR, LOG_DIR, CHROME_WORKER_DIR, APPLY_WORKER_DIR]:
+        directory.mkdir(parents=True, exist_ok=True)
+
+
+def _read_text_with_legacy(current: Path, legacy: Path | None = None, *, encoding: str = "utf-8") -> str | None:
+    """Read current user data, falling back to a legacy file."""
+    if current.exists():
+        return current.read_text(encoding=encoding)
+    if legacy is not None and legacy.exists():
+        return legacy.read_text(encoding=encoding)
+    return None
+
+
+def _copy_if_present(source: Path, target: Path, *, overwrite: bool = False) -> str:
+    """Copy a file when available and report the action taken."""
+    if not source.exists():
+        return "missing"
+    try:
+        if source.resolve() == target.resolve():
+            return "skipped"
+    except Exception:
+        pass
+    if target.exists() and not overwrite:
+        return "skipped"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(source, target)
+    return "copied"
+
+
+def migrate_legacy_user_data(
+    *,
+    source_dir: Path | None = None,
+    target_dir: Path | None = None,
+    overwrite: bool = False,
+) -> dict[str, str]:
+    """Copy legacy files into the current DivApply layout.
+
+    This intentionally preserves the current files unless overwrite=True.
+    The helper is used by the CLI migrate command and is safe to call on a
+    fresh install or repeatedly during upgrade troubleshooting.
+    """
+    source_root = Path(source_dir or LEGACY_APP_DIR)
+    target_root = Path(target_dir or APP_DIR)
+    results = {
+        "profile": _copy_if_present(source_root / "profile.json", target_root / "profile.json", overwrite=overwrite),
+        "searches": _copy_if_present(source_root / "searches.yaml", target_root / "searches.yaml", overwrite=overwrite),
+        "env": _copy_if_present(source_root / ".env", target_root / ".env", overwrite=overwrite),
+        "resume_txt": _copy_if_present(source_root / "resume.txt", target_root / "resume.txt", overwrite=overwrite),
+        "resume_pdf": _copy_if_present(source_root / "resume.pdf", target_root / "resume.pdf", overwrite=overwrite),
+        "database": _copy_if_present(source_root / "applypilot.db", target_root / "divapply.db", overwrite=overwrite),
+    }
+    return results
+
+
+def load_profile() -> dict:
+    """Load user profile from ~/.divapply/profile.json."""
+    import json
+
+    raw = _read_text_with_legacy(PROFILE_PATH, LEGACY_PROFILE_PATH)
+    if raw is None:
+        raise FileNotFoundError(
+            f"Profile not found at {PROFILE_PATH}. Run `divapply init` first."
+        )
+    profile = json.loads(raw)
+
+    # Hidden coursework knowledge is stored in SQLite so it can inform
+    # scoring/tailoring without being exposed in the generated resume text.
+    try:
+        from divapply.database import get_coursework, load_coursework_seed
+
+        coursework = get_coursework()
+        if not coursework:
+            coursework = load_coursework_seed()
+    except Exception:
+        coursework = []
+
+    profile["coursework"] = coursework
+    profile["coursework_summary"] = _summarize_coursework(coursework)
+    profile["coursework_skills"] = _summarize_coursework_skills(coursework)
+    return profile
+
+
+def _summarize_coursework(coursework: list[dict]) -> list[str]:
+    """Condense coursework rows into a compact internal-only summary."""
+    if not coursework:
+        return []
+
+    grouped: dict[str, list[str]] = {}
+    for row in coursework:
+        school = (row.get("school") or "Unknown school").strip()
+        title = (row.get("course_title") or row.get("course_code") or "").strip()
+        subject = (row.get("subject_area") or "").strip()
+        if subject:
+            item = f"{title} [{subject}]" if title else subject
+        else:
+            raw = (row.get("raw_text") or "").strip()
+            if raw:
+                first_line = raw.splitlines()[0].strip()
+                item = title or (first_line[:120] + ("..." if len(first_line) > 120 else ""))
+            else:
+                item = title
+        if not item:
+            continue
+        grouped.setdefault(school, [])
+        if item not in grouped[school]:
+            grouped[school].append(item)
+
+    summary: list[str] = []
+    for school, items in grouped.items():
+        summary.append(f"{school}: {', '.join(items[:12])}")
+    return summary
+
+
+def _summarize_coursework_skills(coursework: list[dict]) -> list[str]:
+    """Aggregate coursework skill tags into a compact internal-only summary."""
+    if not coursework:
+        return []
+
+    grouped: dict[str, set[str]] = {}
+    for row in coursework:
+        school = (row.get("school") or "Unknown school").strip()
+        raw_skills = row.get("skills") or []
+        if isinstance(raw_skills, str):
+            try:
+                import json
+                raw_skills = json.loads(raw_skills)
+            except Exception:
+                raw_skills = [s.strip() for s in raw_skills.split(",") if s.strip()]
+        if not isinstance(raw_skills, list):
+            continue
+        grouped.setdefault(school, set()).update(str(skill).strip() for skill in raw_skills if str(skill).strip())
+
+    summary: list[str] = []
+    for school, skills in grouped.items():
+        summary.append(f"{school}: {', '.join(sorted(skills))}")
+    return summary
+
+
+def load_search_config() -> dict:
+    """Load search configuration from ~/.divapply/searches.yaml."""
+    import yaml
+
+    raw = _read_text_with_legacy(SEARCH_CONFIG_PATH, LEGACY_SEARCH_CONFIG_PATH)
+    if raw is None:
+        example = CONFIG_DIR / "searches.example.yaml"
+        if example.exists():
+            return yaml.safe_load(example.read_text(encoding="utf-8"))
+        return {}
+    return yaml.safe_load(raw)
+
+
+def load_sites_config() -> dict:
+    """Load sites.yaml configuration (sites list, manual_ats, blocked, etc.)."""
+    import yaml
+
+    path = CONFIG_DIR / "sites.yaml"
+    if not path.exists():
+        return {}
+    return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+
+
+def is_manual_ats(url: str | None) -> bool:
+    """Check if a URL routes through an ATS that requires manual application."""
+    if not url:
+        return False
+    sites_cfg = load_sites_config()
+    domains = sites_cfg.get("manual_ats", [])
+    url_lower = url.lower()
+    return any(domain in url_lower for domain in domains)
+
+
+def load_blocked_sites() -> tuple[set[str], list[str]]:
+    """Load blocked sites and URL patterns from sites.yaml."""
+    cfg = load_sites_config()
+    blocked = cfg.get("blocked", {})
+    sites = set(blocked.get("sites", []))
+    patterns = blocked.get("url_patterns", [])
+    return sites, patterns
+
+
+def load_blocked_sso() -> list[str]:
+    """Load blocked SSO domains from sites.yaml."""
+    cfg = load_sites_config()
+    return cfg.get("blocked_sso", [])
+
+
+def load_base_urls() -> dict[str, str | None]:
+    """Load site base URLs for URL resolution from sites.yaml."""
+    cfg = load_sites_config()
+    return cfg.get("base_urls", {})
+
+
+DEFAULTS = {
+    "min_score": 7,
+    "max_apply_attempts": 3,
+    "max_tailor_attempts": 5,
+    "poll_interval": 60,
+    "apply_timeout": 300,
+    "viewport": "1280x900",
+}
+
+
+def load_env() -> None:
+    """Load environment variables from ~/.divapply/.env if it exists."""
+    from dotenv import load_dotenv
+
+    if ENV_PATH.exists():
+        load_dotenv(ENV_PATH, override=True)
+    elif LEGACY_ENV_PATH.exists():
+        load_dotenv(LEGACY_ENV_PATH, override=True)
+    load_dotenv()
+
+
+TIER_LABELS = {
+    1: "Discovery",
+    2: "AI Scoring & Tailoring",
+    3: "Full Auto-Apply",
+}
+
+TIER_COMMANDS: dict[int, list[str]] = {
+    1: ["init", "run discover", "run enrich", "status", "dashboard"],
+    2: ["run score", "run tailor", "run cover", "run pdf", "run"],
+    3: ["apply"],
+}
+
+APPLY_AGENT_LABELS = {
+    "codex": "Codex CLI",
+    "claude": "Claude Code CLI",
+}
+
+APPLY_BROWSER_LABELS = {
+    "firefox": "Firefox",
+    "chrome": "Google Chrome",
+    "msedge": "Microsoft Edge",
+    "webkit": "WebKit",
+}
+
+
+def get_available_apply_backends() -> dict[str, str]:
+    """Return detected auto-apply agent CLIs keyed by backend name."""
+    backends: dict[str, str] = {}
+    for name, binary in (("codex", "codex"), ("claude", "claude")):
+        resolved = shutil.which(binary)
+        if resolved:
+            backends[name] = resolved
+    return backends
+
+
+def get_apply_backend(preferred: str | None = None) -> str | None:
+    """Resolve which apply backend to use."""
+    requested = preferred or os.environ.get("DIVAPPLY_APPLY_BACKEND") or os.environ.get("APPLYPILOT_APPLY_BACKEND")
+    available = get_available_apply_backends()
+    if requested:
+        requested = requested.strip().lower()
+        return requested if requested in available else None
+    for name in ("codex", "claude"):
+        if name in available:
+            return name
+    return None
+
+
+def get_apply_backend_label(backend: str | None) -> str:
+    """Return a human-readable label for the apply backend."""
+    if not backend:
+        return "Apply agent CLI"
+    return APPLY_AGENT_LABELS.get(backend, backend)
+
+
+def get_apply_browser(preferred: str | None = None) -> str:
+    """Resolve which Playwright MCP browser channel to use."""
+    requested = preferred or os.environ.get("DIVAPPLY_BROWSER") or os.environ.get("APPLYPILOT_BROWSER") or "firefox"
+    browser = requested.strip().lower()
+    return browser if browser in APPLY_BROWSER_LABELS else "firefox"
+
+
+def get_apply_browser_label(browser: str | None) -> str:
+    """Return a human-readable label for the apply browser."""
+    if not browser:
+        return "Browser"
+    return APPLY_BROWSER_LABELS.get(browser, browser)
+
+
+def get_tier(preferred_backend: str | None = None, preferred_browser: str | None = None) -> int:
+    """Detect the current tier based on available dependencies.
+
+    Args:
+        preferred_backend: Optional backend to evaluate instead of the env/default backend.
+        preferred_browser: Optional browser to evaluate instead of the env/default browser.
+    """
+    load_env()
+
+    has_llm = any(os.environ.get(key) for key in ("GEMINI_API_KEY", "OPENAI_API_KEY", "LLM_URL"))
+    if not has_llm:
+        return 1
+
+    has_apply_agent = get_apply_backend(preferred_backend) is not None
+    browser = get_apply_browser(preferred_browser)
+    has_browser = True
+    if browser == "chrome":
+        try:
+            get_chrome_path()
+        except FileNotFoundError:
+            has_browser = False
+
+    if has_apply_agent and has_browser and shutil.which("npx") is not None:
+        return 3
+
+    return 2
+
+
+def check_tier(
+    required: int,
+    feature: str,
+    preferred_backend: str | None = None,
+    preferred_browser: str | None = None,
+) -> None:
+    """Raise SystemExit with a clear message if the current tier is too low."""
+    current = get_tier(preferred_backend=preferred_backend, preferred_browser=preferred_browser)
+    if current >= required:
+        return
+
+    from rich.console import Console
+
+    console = Console(stderr=True)
+    missing: list[str] = []
+
+    if required >= 2 and not any(os.environ.get(key) for key in ("GEMINI_API_KEY", "OPENAI_API_KEY", "LLM_URL")):
+        missing.append("LLM API key — run [bold]divapply init[/bold] or set GEMINI_API_KEY")
+    if required >= 3:
+        if get_apply_backend(preferred_backend) is None:
+            missing.append("Apply agent CLI — install Codex or Claude Code for auto-apply")
+        if shutil.which("npx") is None:
+            missing.append("Node.js / npx — install Node.js 18+ for Playwright MCP")
+        if get_apply_browser(preferred_browser) == "chrome":
+            try:
+                get_chrome_path()
+            except FileNotFoundError:
+                missing.append("Chrome/Chromium — install or set CHROME_PATH")
+
+    console.print(
+        f"\n[red]'{feature}' requires {TIER_LABELS.get(required, f'Tier {required}')} (Tier {required}).[/red]\n"
+        f"Current tier: {TIER_LABELS.get(current, f'Tier {current}')} (Tier {current})."
+    )
+    if missing:
+        console.print("\n[yellow]Missing:[/yellow]")
+        for item in missing:
+            console.print(f"  - {item}")
+    console.print()
+    raise SystemExit(1)
+