applybot 1.0.0__tar.gz

applybot-1.0.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: applybot
+Version: 1.0.0
+Summary: Automate your job search pipeline — scrape, score, generate tailored resumes, and auto-apply.
+License: MIT
+Project-URL: Homepage, https://github.com/Ramidoz/applybot
+Project-URL: Repository, https://github.com/Ramidoz/applybot
+Project-URL: Bug Tracker, https://github.com/Ramidoz/applybot/issues
+Keywords: job-search,automation,resume,linkedin,playwright
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0
+Requires-Dist: prompt_toolkit>=3.0
+Requires-Dist: python-docx>=1.1
+Requires-Dist: requests>=2.31
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: rich>=13.0
+Provides-Extra: browser
+Requires-Dist: playwright>=1.40; extra == "browser"
+Provides-Extra: llm
+Requires-Dist: anthropic>=0.20; extra == "llm"
+Requires-Dist: openai>=1.10; extra == "llm"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: responses>=0.25; extra == "dev"
+
+# ApplyBot
+
+Automate your job search pipeline — for any profession.
+
+## Quick start
+
+### Technical users
+```bash
+pip install applybot
+applybot init          # 2-min guided wizard
+applybot run --dry-run # test without submitting
+applybot run           # go live
+```
+
+### Non-technical users
+Double-click `installers/install.bat` (Windows) or `installers/install.sh` (Mac/Linux).
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `applybot init` | Guided setup wizard |
+| `applybot login linkedin` | Save LinkedIn session (for auto-apply) |
+| `applybot run` | Full pipeline |
+| `applybot run --dry-run` | Test without submitting |
+| `applybot run --no-apply` | Scrape + generate docs only |
+| `applybot status` | Print status table in terminal |
+| `applybot dashboard` | Rebuild + open dashboard |
+
+## Configuration
+
+All settings live in `applybot.json` (created by `applybot init`).
+Never commit this file — it contains your API key.
+
+## Browser automation
+
+Auto-apply to LinkedIn Easy Apply, Greenhouse, and Lever.
+
+**Setup (one time):**
+```bash
+pip install "applybot[browser]"
+playwright install chrome
+applybot login linkedin    # opens Chrome — log in, then close the window
+```
+
+Cookies are saved to `sessions/linkedin_cookies.json`. Keep this file private.
+
+**Supported platforms:**
+- LinkedIn Easy Apply
+- Greenhouse
+- Lever
+
+## LLM setup (optional)
+
+ApplyBot can use an LLM to answer open-text custom questions on application forms.
+
+Set `llm_provider` in `applybot.json` to one of:
+
+| Provider | Description |
+|---|---|
+| `none` (default) | Skip custom questions — fill manually |
+| `claude` | Anthropic Claude (requires `llm_api_key`) |
+| `openai` | OpenAI GPT (requires `llm_api_key`) |
+| `custom` | Any OpenAI-compatible endpoint (set `llm_custom_url`) |
+
+Example config for Claude:
+```json
+{
+  "llm_provider": "claude",
+  "llm_api_key": "sk-ant-...",
+  "llm_model": "claude-haiku-4-5-20251001"
+}
+```

applybot-1.0.0/README.md

@@ -0,0 +1,73 @@
+# ApplyBot
+
+Automate your job search pipeline — for any profession.
+
+## Quick start
+
+### Technical users
+```bash
+pip install applybot
+applybot init          # 2-min guided wizard
+applybot run --dry-run # test without submitting
+applybot run           # go live
+```
+
+### Non-technical users
+Double-click `installers/install.bat` (Windows) or `installers/install.sh` (Mac/Linux).
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `applybot init` | Guided setup wizard |
+| `applybot login linkedin` | Save LinkedIn session (for auto-apply) |
+| `applybot run` | Full pipeline |
+| `applybot run --dry-run` | Test without submitting |
+| `applybot run --no-apply` | Scrape + generate docs only |
+| `applybot status` | Print status table in terminal |
+| `applybot dashboard` | Rebuild + open dashboard |
+
+## Configuration
+
+All settings live in `applybot.json` (created by `applybot init`).
+Never commit this file — it contains your API key.
+
+## Browser automation
+
+Auto-apply to LinkedIn Easy Apply, Greenhouse, and Lever.
+
+**Setup (one time):**
+```bash
+pip install "applybot[browser]"
+playwright install chrome
+applybot login linkedin    # opens Chrome — log in, then close the window
+```
+
+Cookies are saved to `sessions/linkedin_cookies.json`. Keep this file private.
+
+**Supported platforms:**
+- LinkedIn Easy Apply
+- Greenhouse
+- Lever
+
+## LLM setup (optional)
+
+ApplyBot can use an LLM to answer open-text custom questions on application forms.
+
+Set `llm_provider` in `applybot.json` to one of:
+
+| Provider | Description |
+|---|---|
+| `none` (default) | Skip custom questions — fill manually |
+| `claude` | Anthropic Claude (requires `llm_api_key`) |
+| `openai` | OpenAI GPT (requires `llm_api_key`) |
+| `custom` | Any OpenAI-compatible endpoint (set `llm_custom_url`) |
+
+Example config for Claude:
+```json
+{
+  "llm_provider": "claude",
+  "llm_api_key": "sk-ant-...",
+  "llm_model": "claude-haiku-4-5-20251001"
+}
+```

applybot-1.0.0/applybot/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

applybot-1.0.0/applybot/apply.py

@@ -0,0 +1,215 @@
+"""Browser automation for form submission."""
+from __future__ import annotations
+from pathlib import Path
+from typing import Any
+
+from applybot.scraper import JobPost
+from applybot.contextual import answer_question
+
+
+def detect_platform(url: str) -> str:
+    """Return platform name from job URL: linkedin | greenhouse | lever | other."""
+    if "linkedin.com" in url:
+        return "linkedin"
+    if "greenhouse.io" in url:
+        return "greenhouse"
+    if "lever.co" in url:
+        return "lever"
+    return "other"
+
+
+# Maps config keys to common form field label patterns
+_FIELD_MAP = {
+    "email": ["email", "e-mail"],
+    "phone": ["phone", "mobile", "telephone"],
+    "name": ["full name", "your name", "first and last name"],
+    "linkedin_url": ["linkedin", "linkedin url", "linkedin profile"],
+}
+
+
+def _fill_standard_fields(page: Any, config: dict[str, Any]) -> None:
+    """Fill common form fields (email, phone, name) from config."""
+    for config_key, labels in _FIELD_MAP.items():
+        value = config.get(config_key, "")
+        if not value:
+            continue
+        for label in labels:
+            try:
+                safe_label = label.replace("'", "\\'")
+                locator = page.locator(f"input[placeholder*='{safe_label}' i], input[aria-label*='{safe_label}' i]")
+                if locator.count() > 0:
+                    locator.first.fill(value)
+                    break
+            except Exception:
+                pass
+
+
+def _answer_custom_questions(page: Any, job: JobPost, config: dict[str, Any], resume_text: str) -> None:
+    """Detect open-text textareas not in standard field map and fill via LLM."""
+    if config.get("llm_provider", "none") == "none":
+        return
+    try:
+        textareas = page.locator("textarea")
+        count = textareas.count()
+        for i in range(count):
+            ta = textareas.nth(i)
+            label_text = ""
+            try:
+                labelledby_id = ta.get_attribute("aria-labelledby") or ""
+                own_id = ta.get_attribute("id") or ""
+                if labelledby_id:
+                    label_el = page.locator(f"#{labelledby_id}")
+                    if label_el.count() > 0:
+                        label_text = label_el.first.inner_text()
+                elif own_id:
+                    label_el = page.locator(f"label[for='{own_id}']")
+                    if label_el.count() > 0:
+                        label_text = label_el.first.inner_text()
+            except Exception:
+                pass
+            if label_text:
+                answer = answer_question(label_text, job.description, resume_text, config)
+                if answer:
+                    ta.fill(answer)
+    except Exception:
+        pass
+
+
+def _handle_linkedin(page: Any, job: JobPost, config: dict[str, Any], resume_text: str) -> str:
+    """Handle LinkedIn Easy Apply flow. Returns status string."""
+    try:
+        page.goto(job.url, wait_until="domcontentloaded", timeout=15000)
+
+        easy_apply = page.locator("button:has-text('Easy Apply'), button[aria-label*='Easy Apply' i]")
+        if easy_apply.count() == 0:
+            return "needs_action"
+
+        easy_apply.first.click()
+        page.wait_for_timeout(1000)
+
+        # Multi-step modal: loop through Next buttons until Submit appears
+        max_steps = 10
+        for _ in range(max_steps):
+            _fill_standard_fields(page, config)
+            _answer_custom_questions(page, job, config, resume_text)
+
+            submit_btn = page.locator(
+                "button[aria-label*='Submit application' i], button:has-text('Submit application')"
+            )
+            if submit_btn.count() > 0:
+                submit_btn.first.click()
+                page.wait_for_timeout(2000)
+                return "submitted"
+
+            next_btn = page.locator(
+                "button[aria-label*='Continue to next step' i], button:has-text('Next')"
+            )
+            if next_btn.count() > 0:
+                next_btn.first.click()
+                page.wait_for_timeout(800)
+            else:
+                # No next and no submit — stuck or form not supported
+                return "needs_action"
+
+        return "needs_action"  # exceeded max_steps
+    except Exception:
+        return "failed"
+
+
+def _handle_greenhouse(page: Any, job: JobPost, config: dict[str, Any], resume_text: str) -> str:
+    """Handle Greenhouse application form. Returns status string."""
+    try:
+        page.goto(job.url, wait_until="domcontentloaded", timeout=15000)
+        page.wait_for_timeout(1000)
+
+        _fill_standard_fields(page, config)
+        _answer_custom_questions(page, job, config, resume_text)
+
+        submit_btn = page.locator(
+            "button[type='submit'], input[type='submit'], button:has-text('Submit')"
+        )
+        if submit_btn.count() > 0:
+            submit_btn.first.click()
+            page.wait_for_timeout(2000)
+            return "submitted"
+
+        return "needs_action"
+    except Exception:
+        return "failed"
+
+
+def _handle_lever(page: Any, job: JobPost, config: dict[str, Any], resume_text: str) -> str:
+    """Handle Lever application form. Returns status string."""
+    try:
+        page.goto(job.url, wait_until="domcontentloaded", timeout=15000)
+
+        apply_btn = page.locator(
+            "a:has-text('Apply'), button:has-text('Apply'), a[href*='apply']"
+        )
+        if apply_btn.count() == 0:
+            return "needs_action"
+
+        apply_btn.first.click()
+        page.wait_for_timeout(1000)
+
+        _fill_standard_fields(page, config)
+        _answer_custom_questions(page, job, config, resume_text)
+
+        submit_btn = page.locator(
+            "button:has-text('Submit application'), button[type='submit'], input[type='submit']"
+        )
+        if submit_btn.count() > 0:
+            submit_btn.first.click()
+            page.wait_for_timeout(2000)
+            return "submitted"
+
+        return "needs_action"
+    except Exception:
+        return "failed"
+
+
+def submit_application(job: JobPost, config: dict[str, Any], resume_text: str = "", _page=None) -> str:
+    """Submit a job application. Returns status string.
+
+    _page: injectable Playwright page for testing (skips browser launch when provided).
+    """
+    platform = detect_platform(job.url)
+
+    if _page is not None:
+        # Testing path — use the provided page directly
+        return _dispatch(platform, _page, job, config, resume_text)
+
+    # Production path — launch Playwright
+    from playwright.sync_api import sync_playwright  # lazy import
+    cookies_path = Path("sessions") / "linkedin_cookies.json"
+
+    with sync_playwright() as pw:
+        browser = pw.chromium.launch(channel="chrome", headless=False)
+        context = browser.new_context()
+
+        # Load saved cookies if available
+        if cookies_path.exists():
+            import json
+            cookies = json.loads(cookies_path.read_text(encoding="utf-8"))
+            context.add_cookies(cookies)
+
+        page = context.new_page()
+        try:
+            result = _dispatch(platform, page, job, config, resume_text)
+        finally:
+            context.close()
+            browser.close()
+
+    return result
+
+
+def _dispatch(platform: str, page: Any, job: JobPost, config: dict[str, Any], resume_text: str = "") -> str:
+    """Route to the correct platform handler."""
+    if platform == "linkedin":
+        return _handle_linkedin(page, job, config, resume_text)
+    elif platform == "greenhouse":
+        return _handle_greenhouse(page, job, config, resume_text)
+    elif platform == "lever":
+        return _handle_lever(page, job, config, resume_text)
+    else:
+        return "needs_action"

applybot-1.0.0/applybot/cli.py

@@ -0,0 +1,131 @@
+"""Click entry point for all applybot commands."""
+import click
+from rich.console import Console
+
+console = Console()
+
+try:
+    from playwright.sync_api import sync_playwright
+except ImportError:
+    sync_playwright = None  # type: ignore[assignment]
+
+
+@click.group()
+@click.version_option()
+def cli():
+    """ApplyBot - automate your job search pipeline."""
+
+
+@cli.command()
+@click.option("--dir", "project_dir", default=".", show_default=True,
+              help="Directory to write applybot.json into.")
+def init(project_dir):
+    """Interactive setup wizard — creates applybot.json."""
+    from pathlib import Path
+    from applybot.wizard import run_wizard
+    run_wizard(output_dir=Path(project_dir))
+
+
+@cli.command()
+@click.argument("platform", type=click.Choice(["linkedin"]))
+def login(platform):
+    """Save session cookies for a platform (one-time login)."""
+    import json
+    from pathlib import Path
+
+    if platform == "linkedin":
+        if sync_playwright is None:
+            console.print("[red]Playwright is not installed. Run: pip install playwright\nAlso ensure Google Chrome is installed (channel='chrome').[/red]")
+            return
+
+        console.print("[yellow]Opening Chrome for LinkedIn login...[/yellow]")
+        console.print("Log in at linkedin.com, then close the browser window.")
+        console.print("[dim]Cookies will be saved automatically on close.[/dim]")
+
+        sessions_dir = Path("sessions")
+        sessions_dir.mkdir(exist_ok=True)
+        cookies_path = sessions_dir / "linkedin_cookies.json"
+
+        with sync_playwright() as pw:
+            browser = pw.chromium.launch(channel="chrome", headless=False)
+            context = browser.new_context()
+            page = context.new_page()
+            page.goto("https://www.linkedin.com/login")
+            page.wait_for_event("close", timeout=300_000)
+            cookies = context.cookies()
+            context.close()
+            browser.close()
+
+        cookies_path.write_text(json.dumps(cookies, ensure_ascii=False), encoding="utf-8")
+        console.print(f"[green]Cookies saved to {cookies_path}[/green]")
+
+
+@cli.command()
+@click.option("--dry-run", "dry_run", is_flag=True, default=False,
+              help="Run pipeline without submitting any applications.")
+@click.option("--no-apply", "no_apply", is_flag=True, default=False,
+              help="Scraper-only mode: scrape, score, generate - no form submission.")
+@click.option("--config", "config_path", default="applybot.json", show_default=True)
+def run(dry_run, no_apply, config_path):
+    """Full pipeline: scrape, score, generate, apply, dashboard."""
+    from pathlib import Path
+    from applybot.config import load_config
+    from applybot.pipeline import run_pipeline
+
+    cfg = load_config(Path(config_path))
+    run_pipeline(cfg, dry_run=dry_run, no_apply=no_apply)
+
+
+@cli.command()
+@click.option("--config", "config_path", default="applybot.json", show_default=True)
+def status(config_path):
+    """Print ASCII status table of all applications."""
+    from pathlib import Path
+    from applybot.tracker import load_tracker
+    from rich.table import Table
+
+    tracker = load_tracker(Path("applications_tracker.json"))
+    apps = tracker["applications"]
+
+    table = Table(title="ApplyBot Status", show_lines=True)
+    table.add_column("Company", style="bold")
+    table.add_column("Role")
+    table.add_column("Status")
+    table.add_column("Score")
+    table.add_column("Applied")
+
+    STATUS_LABELS = {
+        "submitted": "✅ Applied!",
+        "needs_action": "👋 Needs Your Help",
+        "captcha": "🤖 CAPTCHA Blocked",
+        "ai_answered": "🤖 AI Filled",
+        "failed": "❌ Failed",
+        "expired": "💨 Expired",
+        "dry_run": "🧪 Test Run",
+    }
+
+    for app in sorted(apps, key=lambda a: a.get("applied_date") or "", reverse=True):
+        table.add_row(
+            app.get("company", ""),
+            app.get("role", ""),
+            STATUS_LABELS.get(app.get("status", ""), app.get("status", "")),
+            str(app.get("score", "")),
+            app.get("applied_date") or "—",
+        )
+
+    console.print(table if apps else "[dim]No applications yet. Run 'applybot run' to get started.[/dim]")
+
+
+@cli.command()
+@click.option("--config", "config_path", default="applybot.json", show_default=True)
+def dashboard(config_path):
+    """Rebuild dashboard HTML and open in browser."""
+    from pathlib import Path
+    from applybot.config import load_config
+    from applybot.tracker import load_tracker
+    from applybot.dashboard import build_dashboard, open_dashboard
+
+    cfg = load_config(Path(config_path))
+    tracker = load_tracker(Path("applications_tracker.json"))
+    out_path = build_dashboard(tracker, output_dir=Path("output"))
+    open_dashboard(out_path)

applybot-1.0.0/applybot/config.py

@@ -0,0 +1,69 @@
+"""Load, save, and validate applybot.json configuration."""
+from __future__ import annotations
+import json
+from pathlib import Path
+from typing import Any
+
+
+REQUIRED_KEYS = [
+    "name", "email", "phone", "linkedin_url", "target_roles",
+    "remote_only", "location", "salary_min", "salary_max",
+    "years_of_experience", "work_authorized", "require_sponsorship",
+    "master_resume", "autofill", "score_threshold", "llm_provider",
+    "llm_api_key", "llm_model", "llm_custom_url", "llm_custom_auth_header",
+]
+
+DEFAULTS = {
+    "portfolio_url": "",
+    "blocklist_companies": [],
+    "location": "",
+    "llm_api_key": "",
+    "llm_model": "",
+    "llm_custom_url": "",
+    "llm_custom_auth_header": "",
+}
+
+
+class ConfigError(Exception):
+    pass
+
+
+def load_config(path: Path) -> dict[str, Any]:
+    """Load and validate applybot.json. Raises ConfigError on failure."""
+    path = Path(path)
+    if not path.exists():
+        raise ConfigError(f"Config file not found: {path}")
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as e:
+        raise ConfigError(f"Config file contains invalid JSON: {e}") from e
+    # Apply defaults for optional fields
+    for k, v in DEFAULTS.items():
+        data.setdefault(k, v)
+    validate_config(data)
+    return data
+
+
+def save_config(config: dict[str, Any], path: Path) -> None:
+    """Write config dict to applybot.json."""
+    Path(path).write_text(
+        json.dumps(config, indent=2, ensure_ascii=False), encoding="utf-8"
+    )
+
+
+def validate_config(config: dict[str, Any]) -> None:
+    """Raise ConfigError if config is missing required fields or has bad values."""
+    for key in REQUIRED_KEYS:
+        if key not in config:
+            raise ConfigError(f"Missing required config field: {key}")
+
+    if not isinstance(config["target_roles"], list) or len(config["target_roles"]) == 0:
+        raise ConfigError("target_roles must be a non-empty list of job title strings")
+
+    threshold = config["score_threshold"]
+    if not isinstance(threshold, (int, float)) or not (0 <= threshold <= 100):
+        raise ConfigError(f"score_threshold must be a number between 0 and 100, got: {threshold}")
+
+    valid_providers = {"claude", "openai", "custom", "none"}
+    if config["llm_provider"] not in valid_providers:
+        raise ConfigError(f"llm_provider must be one of {valid_providers}")