chameleon-cv 0.1.0

package/scripts/job_scanner/parsers/jooble.py

@@ -0,0 +1,68 @@
+"""Jooble — job aggregator with structured API. Tier 1 (free tier key).
+
+Requires JOOBLE_API_KEY env var. Falls back gracefully.
+"""
+from __future__ import annotations
+
+import json
+import os
+import urllib.request
+import urllib.error
+from typing import Any
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class JoobleParser(BaseParser):
+    platform_name = "jooble"
+
+    def fetch_jobs(self, query: str = "", **kwargs: Any) -> list[JobListing]:
+        api_key = os.environ.get("JOOBLE_API_KEY")
+        if not api_key:
+            return []
+
+        url = f"https://jooble.org/api/{api_key}"
+        payload = {"keywords": query or "software engineer", "page": 1}
+        if kwargs.get("location"):
+            payload["location"] = kwargs["location"]
+
+        try:
+            req = urllib.request.Request(
+                url,
+                data=json.dumps(payload).encode(),
+                headers={
+                    "Content-Type": "application/json",
+                    "User-Agent": "Chameleon/1.0",
+                },
+            )
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                data = json.loads(resp.read().decode())
+        except (urllib.error.URLError, urllib.error.HTTPError, json.JSONDecodeError, OSError):
+            return []
+
+        jobs: list[JobListing] = []
+        for j in data.get("jobs", [])[:kwargs.get("limit", 25)]:
+            title = (j.get("title") or "").strip()
+            company = (j.get("company") or "Unknown").strip()
+            url = j.get("link") or j.get("url") or ""
+            desc = (j.get("snippet") or j.get("description") or "")[:2000]
+            location = j.get("location") or ""
+            salary = j.get("salary") or ""
+            remote = "remote" in str(location).lower() or "anywhere" in str(desc).lower()
+
+            job_id = j.get("id") or f"jooble-{hash(title + company)}"
+            jobs.append(JobListing(
+                job_id=f"job-{job_id}",
+                title=title,
+                company=company,
+                url=url,
+                location=location,
+                description=desc,
+                salary=str(salary),
+                source=self.platform_name,
+                remote=remote,
+                tags=[],
+            ))
+        return jobs

package/scripts/job_scanner/parsers/linkedin.py

@@ -0,0 +1,140 @@
+"""LinkedIn Jobs — guest API + browser fallback for anti-bot."""
+from __future__ import annotations
+
+import re
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class LinkedInParser(BaseParser):
+    platform_name = "linkedin"
+    GUEST_API = "https://www.linkedin.com/jobs-guest/jobs/api/seeMoreJobPostings/search"
+    BROWSE_URL = "https://www.linkedin.com/jobs/search"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        params = {
+            "keywords": query,
+            "start": kwargs.get("start", 0),
+            "f_TPR": "r604800",
+        }
+        location = kwargs.get("location", "")
+        if location:
+            params["location"] = location
+
+        jobs = []
+
+        # Attempt 1: Guest API (HTTP)
+        resp = self._http_get(
+            self.GUEST_API,
+            params=params,
+            headers={"Accept": "text/html,application/xhtml+xml"},
+        )
+        if resp and len(resp.text) > 500:
+            self._parse_guest_api(resp.text, jobs, query, limit)
+
+        # Attempt 2: Browser automation fallback
+        if not jobs and self._browser_available():
+            browse_params = {
+                "keywords": query or "software engineer",
+                "f_TPR": "r604800",
+            }
+            qs = "&".join(f"{k}={v}" for k, v in browse_params.items())
+            browser_resp = self._browser_get(
+                f"{self.BROWSE_URL}?{qs}",
+                timeout=20,
+                wait_selector=".job-card-container",
+                scroll=True,
+            )
+            if browser_resp and not self._is_login_wall(browser_resp.text):
+                self._parse_browser_html(browser_resp.text, jobs, query, limit)
+
+        return jobs
+
+    def _parse_guest_api(self, html: str, jobs: list, query: str, limit: int) -> None:
+        card_pattern = re.compile(
+            r'<a[^>]*href="(https://www\.linkedin\.com/jobs/view/[^"]+)"[^>]*>.*?'
+            r'<h3[^>]*>([^<]+)</h3>.*?'
+            r'<h4[^>]*>([^<]+)</h4>',
+            re.DOTALL,
+        )
+        for match in card_pattern.finditer(html):
+            url, title, company = match.groups()
+            if query and query.lower() not in f"{title} {company}".lower():
+                continue
+            jobs.append(
+                JobListing(
+                    title=self._clean_html(title).strip(),
+                    company=self._clean_html(company).strip(),
+                    url=url.split("?")[0],
+                    location="",
+                    remote=True,
+                    source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                break
+
+    def _parse_browser_html(self, html: str, jobs: list, query: str, limit: int) -> None:
+        # Try JSON-LD first
+        ld = self._extract_json_ld(html)
+        seen = set()
+        for entry in ld:
+            if entry.get("@type") != "JobPosting":
+                continue
+            title = (entry.get("title", "") or "").strip()
+            org = entry.get("hiringOrganization", {})
+            company_name = (org.get("name", "") if isinstance(org, dict) else str(org)).strip()
+            url = entry.get("url", "") or entry.get("directApply", "")
+            if isinstance(url, dict):
+                url = url.get("url", "")
+            if not title or not company_name:
+                continue
+            key = f"{title}|{company_name}"
+            if key in seen:
+                continue
+            seen.add(key)
+            if query and query.lower() not in f"{title} {company_name}".lower():
+                continue
+            jobs.append(
+                JobListing(
+                    title=title,
+                    company=company_name,
+                    url=url,
+                    location="Remote",
+                    remote=True,
+                    description=self._truncate(self._clean_html(entry.get("description", "")), 500),
+                    source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                break
+
+        # Fallback: HTML card pattern
+        if not jobs:
+            card = re.compile(
+                r'class="[^"]*job-card-container[^"]*"[^>]*>.*?'
+                r'<a[^>]*href="(/jobs/view/[^"]+)"[^>]*>.*?'
+                r'<span[^>]*>([^<]+)</span>.*?'
+                r'<span[^>]*>([^<]+)</span>',
+                re.DOTALL,
+            )
+            for match in card.finditer(html):
+                path, title, company = match.groups()
+                if query and query.lower() not in f"{title} {company}".lower():
+                    continue
+                jobs.append(
+                    JobListing(
+                        title=self._clean_html(title).strip(),
+                        company=self._clean_html(company).strip(),
+                        url=f"https://www.linkedin.com{path}",
+                        location="",
+                        remote=True,
+                        source=self.platform_name,
+                    )
+                )
+                if len(jobs) >= limit:
+                    break

package/scripts/job_scanner/parsers/opentoworkremote.py

@@ -0,0 +1,53 @@
+"""OpenToWorkRemote — RapidAPI aggregator (requires API key)."""
+
+from __future__ import annotations
+
+import httpx
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class OpenToWorkRemoteParser(BaseParser):
+    platform_name = "opentoworkremote"
+    API_URL = "https://remote-jobs1.p.rapidapi.com/search"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        import os
+        api_key = kwargs.get("rapidapi_key") or os.environ.get("RAPIDAPI_KEY", "")
+        if not api_key:
+            return []
+
+        params = {"title": query, "limit": limit}
+        try:
+            resp = httpx.get(
+                self.API_URL,
+                params=params,
+                timeout=15,
+                headers={
+                    "X-RapidAPI-Key": api_key,
+                    "X-RapidAPI-Host": "remote-jobs1.p.rapidapi.com",
+                },
+            )
+            resp.raise_for_status()
+            data = resp.json()
+        except Exception:
+            return []
+
+        jobs = []
+        for item in data.get("jobs", data if isinstance(data, list) else [])[:limit]:
+            jobs.append(
+                JobListing(
+                    title=item.get("title", ""),
+                    company=item.get("company_name", item.get("company", "")),
+                    url=item.get("url", item.get("job_url", "")),
+                    location=item.get("location", "Remote"),
+                    remote=True,
+                    tags=item.get("tags", []),
+                    source=self.platform_name,
+                )
+            )
+        return jobs

package/scripts/job_scanner/parsers/relocate.py

@@ -0,0 +1,95 @@
+"""Relocate.me — scraping-based parser for relocation-friendly jobs."""
+
+from __future__ import annotations
+
+import httpx
+import re
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class RelocateParser(BaseParser):
+    platform_name = "relocate"
+    SEARCH_URL = "https://relocate.me/search"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        params = {}
+        if query:
+            params["query"] = query
+
+        resp = self._http_get(self.SEARCH_URL, params=params, timeout=15)
+        if resp is None:
+            return []
+
+        html = resp.text
+        jobs = []
+
+        # Try JSON-LD first
+        ld = self._extract_json_ld(html)
+        seen = set()
+        for entry in ld:
+            if entry.get("@type") != "JobPosting":
+                continue
+            title = (entry.get("title", "") or "").strip()
+            org = entry.get("hiringOrganization", {})
+            company_name = (org.get("name", "") if isinstance(org, dict) else str(org)).strip()
+            url = entry.get("url", "")
+            if not title or not company_name:
+                continue
+            key = f"{title}|{company_name}"
+            if key in seen:
+                continue
+            seen.add(key)
+            if query and query.lower() not in f"{title} {company_name}".lower():
+                continue
+            location = entry.get("jobLocation", "")
+            if isinstance(location, dict):
+                location = location.get("address", {}).get("addressLocality", location.get("name", "Remote"))
+            if isinstance(location, dict):
+                location = "Relocation required"
+            jobs.append(
+                JobListing(
+                    title=title,
+                    company=company_name,
+                    url=url or f"https://relocate.me/job/{title.lower().replace(' ', '-')}",
+                    location=str(location),
+                    remote=False,
+                    tags=["relocation"],
+                    description=self._truncate(self._clean_html(entry.get("description", "")), 500),
+                    source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                break
+
+        # Fallback: HTML card parsing
+        if not jobs:
+            card_pattern = re.compile(
+                r'<a[^>]*href="(/job[^"]+)"[^>]*>.*?'
+                r'<(?:h[234]|span)[^>]*>([^<]+)</.*?'
+                r'(?:<(?:span|div)[^>]*class="[^"]*company[^"]*"[^>]*>([^<]+)<|([^<]{3,50})</)',
+                re.DOTALL,
+            )
+            for match in card_pattern.finditer(html):
+                path, title, company = match.group(1), match.group(2), match.group(3) or match.group(4) or ""
+                if query and query.lower() not in f"{title} {company}".lower():
+                    continue
+                jobs.append(
+                    JobListing(
+                        title=title.strip(),
+                        company=company.strip() if company else "Unknown",
+                        url=f"https://relocate.me{path}",
+                        location="Relocation required",
+                        remote=False,
+                        tags=["relocation"],
+                        source=self.platform_name,
+                    )
+                )
+                if len(jobs) >= limit:
+                    break
+
+        return jobs

package/scripts/job_scanner/parsers/remote_rocketship.py

@@ -0,0 +1,90 @@
+"""Remote Rocketship — parser with HTTP + Playwright browser fallback."""
+from __future__ import annotations
+
+import re
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class RemoteRocketshipParser(BaseParser):
+    platform_name = "remote_rocketship"
+    BASE_URL = "https://remoterocketship.com"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        params = {}
+        if query:
+            params["q"] = query
+
+        jobs = []
+
+        # Attempt 1: HTTP (usually Cloudflare-blocked)
+        resp = self._http_get(self.BASE_URL, params=params)
+        if resp and "cloudflare" not in resp.text[:500].lower() and len(resp.text) > 2000:
+            self._parse_html(resp.text, jobs, query, limit)
+
+        # Attempt 2: Browser fallback
+        if not jobs and self._browser_available():
+            qs = "&".join(f"{k}={v}" for k, v in params.items()) if params else ""
+            url = f"{self.BASE_URL}?{qs}" if qs else self.BASE_URL
+            browser_resp = self._browser_get(
+                url, timeout=25,
+                wait_selector="[class*='job'], [class*='card'], article, .position",
+                scroll=True,
+            )
+            if browser_resp and not self._is_login_wall(browser_resp.text):
+                self._parse_html(browser_resp.text, jobs, query, limit)
+
+        return jobs
+
+    def _parse_html(self, html: str, jobs: list, query: str, limit: int) -> None:
+        # Try JSON-LD
+        ld = self._extract_json_ld(html)
+        seen = set()
+        for entry in ld:
+            if entry.get("@type") != "JobPosting":
+                continue
+            title = (entry.get("title", "") or "").strip()
+            org = entry.get("hiringOrganization", {})
+            company_name = (org.get("name", "") if isinstance(org, dict) else str(org)).strip()
+            url = entry.get("url", "")
+            if not title or not company_name:
+                continue
+            key = f"{title}|{company_name}"
+            if key in seen:
+                continue
+            seen.add(key)
+            if query and query.lower() not in f"{title} {company_name}".lower():
+                continue
+            jobs.append(
+                JobListing(
+                    title=title, company=company_name, url=url,
+                    location="Remote", remote=True, source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                return
+
+        # HTML card pattern
+        card = re.compile(
+            r'<a[^>]*href="(/job/[^"]+)"[^>]*>.*?'
+            r'<(?:h[234]|span)[^>]*>([^<]+)</.*?'
+            r'<(?:span|div)[^>]*class="[^"]*(?:company|employer)[^"]*"[^>]*>([^<]+)<',
+            re.DOTALL,
+        )
+        for match in card.finditer(html):
+            path, title, company = match.groups()
+            if query and query.lower() not in f"{title} {company}".lower():
+                continue
+            jobs.append(
+                JobListing(
+                    title=title.strip(), company=company.strip(),
+                    url=f"{self.BASE_URL}{path}",
+                    location="Remote", remote=True, source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                return

package/scripts/job_scanner/parsers/remoteok.py

@@ -0,0 +1,63 @@
+"""Remote OK — free JSON API + RSS, no auth required."""
+
+from __future__ import annotations
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class RemoteOKParser(BaseParser):
+    platform_name = "remoteok"
+    API_URL = "https://remoteok.com/api"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        url = self.API_URL
+        if tags:
+            url += "?tag=" + tags[0]
+
+        resp = self._http_get(url)
+        if resp is None:
+            return []
+
+        try:
+            items = resp.json()
+        except Exception:
+            return []
+
+        # First item is metadata
+        if items and isinstance(items[0], dict) and "legal" in str(items[0]):
+            items = items[1:]
+
+        q = query.lower() if query else ""
+        jobs = []
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            title = item.get("position", "")
+            company = item.get("company", "")
+            job_tags = item.get("tags", [])
+            desc = item.get("description", "")
+            searchable = f"{title} {company} {' '.join(job_tags)} {desc}".lower()
+            if q and q not in searchable:
+                continue
+            jobs.append(
+                JobListing(
+                    title=title,
+                    company=company,
+                    url=item.get("url", f"https://remoteok.com/remote-jobs/{item.get('id', '')}"),
+                    location=item.get("location", "Remote"),
+                    remote=True,
+                    tags=item.get("tags", []),
+                    salary=item.get("salary", ""),
+                    posted_at=item.get("date", ""),
+                    description=self._truncate(item.get("description", "")),
+                    source=self.platform_name,
+                    job_id=str(item.get("id", "")),
+                )
+            )
+            if len(jobs) >= limit:
+                break
+        return jobs

package/scripts/job_scanner/parsers/remotive.py

@@ -0,0 +1,57 @@
+"""Remotive — free JSON API + RSS, no auth required."""
+
+from __future__ import annotations
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class RemotiveParser(BaseParser):
+    platform_name = "remotive"
+    API_URL = "https://remotive.com/api/remote-jobs"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        params: dict = {"limit": min(limit, 100)}
+        if query:
+            params["search"] = query
+        category = kwargs.get("category", "")
+        if category:
+            params["category"] = category
+
+        resp = self._http_get(self.API_URL, params=params)
+        if resp is None:
+            return []
+
+        try:
+            data = resp.json()
+        except Exception:
+            return []
+
+        jobs = []
+        q = query.lower() if query else ""
+        for item in data.get("jobs", []):
+            if q:
+                searchable = f"{item.get('title', '')} {item.get('company_name', '')} {' '.join(item.get('tags', []))}".lower()
+                if q not in searchable:
+                    continue
+            jobs.append(
+                JobListing(
+                    title=item.get("title", ""),
+                    company=item.get("company_name", ""),
+                    url=item.get("url", ""),
+                    location=item.get("candidate_required_location", ""),
+                    remote=item.get("remote", True),
+                    tags=item.get("tags", []),
+                    salary=item.get("salary", ""),
+                    posted_at=item.get("publication_date", ""),
+                    description=self._truncate(self._clean_html(item.get("description", ""))),
+                    source=self.platform_name,
+                    job_id=str(item.get("id", "")),
+                )
+            )
+            if len(jobs) >= limit:
+                break
+        return jobs

package/scripts/job_scanner/parsers/web3_career.py

@@ -0,0 +1,92 @@
+"""Web3 Career — parser for web3/blockchain jobs via JSON-LD."""
+from __future__ import annotations
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class Web3CareerParser(BaseParser):
+    platform_name = "web3_career"
+    BASE_URL = "https://web3.career"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        url = f"{self.BASE_URL}/web3-jobs"
+        if query:
+            slug = query.lower().replace(" ", "+")
+            url = f"{self.BASE_URL}/{slug}+crypto-jobs"
+
+        resp = self._http_get(url)
+        if resp is None:
+            return []
+
+        ld = self._extract_json_ld(resp.text)
+        jobs = []
+        seen = set()
+
+        for entry in ld:
+            if entry.get("@type") != "JobPosting":
+                continue
+            title = (entry.get("title", "") or "").strip()
+            company = entry.get("hiringOrganization", {})
+            if isinstance(company, dict):
+                company_name = (company.get("name", "") or "").strip()
+            else:
+                company_name = str(company).strip() if company else ""
+            # Skip artist/portfolio entries mislabeled as JobPosting
+            if company_name.lower() in ("nftphotographers.xyz",) or not company_name:
+                continue
+            if not title or len(title) < 5:
+                continue
+
+            direct_apply = entry.get("directApply", entry.get("url", ""))
+            if isinstance(direct_apply, dict):
+                direct_apply = direct_apply.get("url", "")
+            if not direct_apply:
+                direct_apply = entry.get("url", "")
+
+            desc = self._clean_html(entry.get("description", ""))
+            location = entry.get("jobLocation", "")
+            if isinstance(location, dict):
+                location = location.get("address", {}).get("addressLocality", location.get("name", "Remote"))
+            if isinstance(location, dict):
+                location = "Remote"
+
+            salary = entry.get("baseSalary", {})
+            salary_str = ""
+            if isinstance(salary, dict):
+                min_v = salary.get("value", {}).get("minValue", salary.get("value", ""))
+                max_v = salary.get("value", {}).get("maxValue", "")
+                if min_v and max_v:
+                    salary_str = f"${min_v} - ${max_v}"
+                elif min_v:
+                    salary_str = f"${min_v}+"
+
+            dedup_key = f"{title}|{company_name}"
+            if dedup_key in seen:
+                continue
+            seen.add(dedup_key)
+
+            if query and query.lower() not in f"{title} {company_name}".lower():
+                continue
+
+            job_url = direct_apply or f"{self.BASE_URL}/job/{title.lower().replace(' ', '-')}"
+            jobs.append(
+                JobListing(
+                    title=title.strip(),
+                    company=company_name.strip(),
+                    url=job_url,
+                    location=location if isinstance(location, str) else "Remote",
+                    remote="remote" in str(location).lower() or "anywhere" in str(location).lower(),
+                    tags=["web3", "crypto"],
+                    description=self._truncate(desc, 500),
+                    salary=salary_str,
+                    source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                break
+
+        return jobs