chameleon-cv 0.1.0

package/scripts/job_scanner/parsers/arc.py

@@ -0,0 +1,65 @@
+"""Arc.dev — parser for remote dev jobs via __NEXT_DATA__."""
+from __future__ import annotations
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class ArcParser(BaseParser):
+    platform_name = "arc"
+    BASE_URL = "https://arc.dev/remote-jobs"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        url = self.BASE_URL
+        if query:
+            slug = query.lower().replace(" ", "-")
+            url = f"{self.BASE_URL}/{slug}"
+
+        resp = self._http_get(url)
+        if resp is None:
+            return []
+
+        data = self._extract_next_data(resp.text)
+        if data is None:
+            return []
+
+        page_props = data.get("props", {}).get("pageProps", {})
+        jobs = []
+
+        for source_key in ("arcJobs", "externalJobs"):
+            items = page_props.get(source_key, [])
+            for item in items[:limit]:
+                company = item.get("company", {})
+                if isinstance(company, dict):
+                    company_name = company.get("name", "")
+                else:
+                    company_name = str(company) if company else ""
+
+                job_title = item.get("title", "") or ""
+                url_str = item.get("urlString", "")
+                job_url = f"https://arc.dev/remote-jobs/{url_str}" if url_str else ""
+
+                categories = item.get("categories", [])
+                tags_list = [c.get("name", str(c)) if isinstance(c, dict) else str(c) for c in categories]
+
+                jobs.append(
+                    JobListing(
+                        title=job_title,
+                        company=company_name,
+                        url=job_url,
+                        location="Remote",
+                        remote=True,
+                        tags=tags_list,
+                        posted_at=item.get("postedAt", ""),
+                        source=self.platform_name,
+                    )
+                )
+                if len(jobs) >= limit:
+                    break
+            if len(jobs) >= limit:
+                break
+
+        return jobs

package/scripts/job_scanner/parsers/crypto_careers.py

@@ -0,0 +1,88 @@
+"""Crypto Careers — parser with HTTP + Playwright browser fallback for Cloudflare."""
+from __future__ import annotations
+
+import re
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class CryptoCareersParser(BaseParser):
+    platform_name = "crypto_careers"
+    BASE_URL = "https://www.crypto-careers.com"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        jobs = []
+
+        # Attempt 1: HTTP (usually Cloudflare-blocked)
+        resp = self._http_get(self.BASE_URL)
+        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 (bypasses Cloudflare)
+        if not jobs and self._browser_available():
+            browser_resp = self._browser_get(
+                self.BASE_URL, timeout=25,
+                wait_selector="[class*='job'], article, .card, tr",
+                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,
+                    tags=["crypto", "blockchain"],
+                    description=self._truncate(self._clean_html(entry.get("description", "")), 500),
+                    source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                return
+
+        # HTML card pattern
+        card = re.compile(
+            r'<a[^>]*href="(/job/[^"]+)"[^>]*>.*?'
+            r'<(?:h[234]|span|div)[^>]*>([^<]+)</.*?'
+            r'<(?:span|div|p)[^>]*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,
+                    tags=["crypto", "blockchain"], source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                return

package/scripts/job_scanner/parsers/dailyremote.py

@@ -0,0 +1,91 @@
+"""DailyRemote — 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 DailyRemoteParser(BaseParser):
+    platform_name = "dailyremote"
+    SEARCH_URL = "https://dailyremote.com/remote-jobs"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        params = {}
+        if query:
+            params["q"] = query
+        params["page"] = kwargs.get("page", 1)
+
+        jobs = []
+
+        # Attempt 1: HTTP
+        resp = self._http_get(self.SEARCH_URL, params=params)
+        if resp and len(resp.text) > 1000:
+            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())
+            browser_resp = self._browser_get(
+                f"{self.SEARCH_URL}?{qs}", timeout=20,
+                wait_selector="[class*='card'], [class*='job'], article, tr",
+                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,
+                    description=self._truncate(self._clean_html(entry.get("description", "")), 500),
+                )
+            )
+            if len(jobs) >= limit:
+                return
+
+        # HTML card pattern
+        card = re.compile(
+            r'<a[^>]*href="(/remote-jobs/[^"]+)"[^>]*>.*?'
+            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"https://dailyremote.com{path}",
+                    location="Remote", remote=True, source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                return

package/scripts/job_scanner/parsers/flexjobs.py

@@ -0,0 +1,91 @@
+"""FlexJobs — 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 FlexJobsParser(BaseParser):
+    platform_name = "flexjobs"
+    SEARCH_URL = "https://www.flexjobs.com/search"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        params = {"search": query}
+        location = kwargs.get("location", "")
+        if location:
+            params["location"] = location
+
+        jobs = []
+
+        # Attempt 1: HTTP
+        resp = self._http_get(self.SEARCH_URL, params=params)
+        if resp and len(resp.text) > 1000:
+            self._parse_html(resp.text, jobs, query, limit, location)
+
+        # Attempt 2: Browser fallback
+        if not jobs and self._browser_available():
+            qs = "&".join(f"{k}={v}" for k, v in params.items())
+            browser_resp = self._browser_get(
+                f"{self.SEARCH_URL}?{qs}", timeout=20,
+                wait_selector="[class*='job'], [class*='card'], .mosaic",
+                scroll=True,
+            )
+            if browser_resp and not self._is_login_wall(browser_resp.text):
+                self._parse_html(browser_resp.text, jobs, query, limit, location)
+
+        return jobs
+
+    def _parse_html(self, html: str, jobs: list, query: str, limit: int, location: str) -> None:
+        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=location or "",
+                    remote=True, tags=["flexible"],
+                    source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                return
+
+        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"https://www.flexjobs.com{path}",
+                    location=location or "", remote=True,
+                    tags=["flexible"], source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                return

package/scripts/job_scanner/parsers/himalayas.py

@@ -0,0 +1,47 @@
+"""Himalayas — free JSON API + RSS, no auth required."""
+
+from __future__ import annotations
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class HimalayasParser(BaseParser):
+    platform_name = "himalayas"
+    API_URL = "https://himalayas.app/jobs/api"
+    SEARCH_URL = "https://himalayas.app/jobs/api/search"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        params: dict = {"limit": min(limit, 50)}
+        url = self.SEARCH_URL if query else self.API_URL
+        if query:
+            params["q"] = query
+
+        resp = self._http_get(url, params=params)
+        if resp is None:
+            return []
+
+        try:
+            data = resp.json()
+        except Exception:
+            return []
+
+        jobs = []
+        for item in data.get("jobs", [])[:limit]:
+            jobs.append(
+                JobListing(
+                    title=item.get("title", ""),
+                    company=item.get("companyName", ""),
+                    url=item.get("applicationLink") or item.get("guid", ""),
+                    location=item.get("location", ""),
+                    remote=item.get("remote", True),
+                    tags=[t.get("name", "") for t in item.get("tags", [])],
+                    posted_at=item.get("datePosted", ""),
+                    description=self._truncate(self._clean_html(item.get("description", ""))),
+                    source=self.platform_name,
+                )
+            )
+        return jobs

package/scripts/job_scanner/parsers/hn_hiring.py

@@ -0,0 +1,94 @@
+"""HN Hiring (Who Is Hiring) — Algolia API, no auth required."""
+
+from __future__ import annotations
+
+import re
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class HNHiringParser(BaseParser):
+    platform_name = "hn_hiring"
+    ALGOLIA_URL = "https://hn.algolia.com/api/v1/search_by_date"
+    ITEMS_URL = "https://hn.algolia.com/api/v1/items"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        # Find the latest "Ask HN: Who is hiring?" thread
+        resp = self._http_get(
+            self.ALGOLIA_URL,
+            params={"tags": "story", "query": "Ask HN Who is hiring"},
+        )
+        if resp is None:
+            return []
+
+        try:
+            hits = resp.json().get("hits", [])
+        except Exception:
+            return []
+
+        # Find the actual "Ask HN: Who is hiring?" thread
+        thread_id = None
+        for hit in hits:
+            title = hit.get("title", "")
+            lower = title.lower()
+            if "ask hn" in lower and "who is hiring?" in lower and "(" in title:
+                thread_id = hit.get("objectID")
+                break
+
+        if not thread_id:
+            return []
+
+        # Fetch thread comments
+        resp = self._http_get(f"{self.ITEMS_URL}/{thread_id}")
+        if resp is None:
+            return []
+
+        try:
+            thread = resp.json()
+        except Exception:
+            return []
+
+        comments = thread.get("children", [])
+
+        jobs = []
+        for comment in comments:
+            text = comment.get("text", "")
+            if not text or comment.get("dead") or comment.get("deleted"):
+                continue
+
+            clean = self._clean_html(text)
+            lines = clean.split("\n")
+            header = lines[0] if lines else ""
+
+            parts = [p.strip() for p in header.split("|")]
+            company = parts[0] if parts else ""
+            title = parts[1] if len(parts) > 1 else ""
+            location = parts[2] if len(parts) > 2 else ""
+
+            if query and query.lower() not in clean.lower():
+                continue
+
+            url = f"https://news.ycombinator.com/item?id={comment.get('id', '')}"
+
+            jobs.append(
+                JobListing(
+                    title=title or "See posting",
+                    company=company,
+                    url=url,
+                    location=location,
+                    remote="remote" in clean.lower(),
+                    tags=[],
+                    posted_at=thread.get("time", ""),
+                    description=self._truncate(clean),
+                    source=self.platform_name,
+                    job_id=str(comment.get("id", "")),
+                )
+            )
+            if len(jobs) >= limit:
+                break
+
+        return jobs

package/scripts/job_scanner/parsers/indeed.py

@@ -0,0 +1,98 @@
+"""Indeed — 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 IndeedParser(BaseParser):
+    platform_name = "indeed"
+    SEARCH_URL = "https://www.indeed.com/jobs"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        params = {"q": query}
+        location = kwargs.get("location", "")
+        if location:
+            params["l"] = location
+        remote = kwargs.get("remote", False)
+        if remote:
+            params["remotejob"] = "032b3046-06a3-4876-8dfd-474eb5e7ed11"
+
+        jobs = []
+
+        # Attempt 1: HTTP
+        resp = self._http_get(self.SEARCH_URL, params=params, retries=1)
+        if resp and len(resp.text) > 1000:
+            self._parse_html(resp.text, jobs, query, limit, location, remote)
+
+        # Attempt 2: Browser fallback
+        if not jobs and self._browser_available():
+            qs = "&".join(f"{k}={v}" for k, v in params.items())
+            browser_resp = self._browser_get(
+                f"{self.SEARCH_URL}?{qs}",
+                timeout=20,
+                wait_selector=".jobsearch-ResultsList",
+                scroll=True,
+            )
+            if browser_resp and not self._is_login_wall(browser_resp.text):
+                self._parse_html(browser_resp.text, jobs, query, limit, location, remote)
+
+        return jobs
+
+    def _parse_html(self, html: str, jobs: list, query: str, limit: int,
+                    location: str, remote: bool) -> 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", "")
+            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=location or "", remote=remote,
+                    description=self._truncate(self._clean_html(entry.get("description", "")), 500),
+                    source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                return
+
+        # Fallback: HTML card pattern
+        card = re.compile(
+            r'<a[^>]*href="(/rc/clk[^"]*|/viewjob[^"]*)"[^>]*>.*?'
+            r'<(?:h2|span)[^>]*class="[^"]*jobTitle[^"]*"[^>]*>([^<]+)</.*?'
+            r'<(?:span|div)[^>]*data-testid="[^"]*company[^"]*"[^>]*>([^<]+)<',
+            re.DOTALL,
+        )
+        for match in card.finditer(html):
+            path, title, company = match.groups()
+            url = f"https://www.indeed.com{path.split('?')[0]}"
+            if query and query.lower() not in f"{title} {company}".lower():
+                continue
+            jobs.append(
+                JobListing(
+                    title=title.strip(), company=company.strip(),
+                    url=url, location=location or "",
+                    remote=remote, source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                return

package/scripts/job_scanner/parsers/jobicy.py

@@ -0,0 +1,60 @@
+"""Jobicy — remote job board with a clean JSON API. Tier 1."""
+from __future__ import annotations
+
+import json
+import os
+import urllib.parse
+import urllib.request
+import urllib.error
+from typing import Any
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class JobicyParser(BaseParser):
+    platform_name = "jobicy"
+
+    def fetch_jobs(self, query: str = "", **kwargs: Any) -> list[JobListing]:
+        api_url = "https://jobicy.com/api/v2/remote-jobs"
+        params = []
+        if query:
+            params.append(f"tag={urllib.parse.quote(query)}")
+        url = api_url + ("?" + "&".join(params) if params else "")
+
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": "Chameleon/1.0"})
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                data = json.loads(resp.read().decode())
+        except (urllib.error.URLError, json.JSONDecodeError, OSError):
+            return []
+
+        jobs: list[JobListing] = []
+        raw_jobs = data.get("jobs", []) if isinstance(data, dict) else data
+        for j in raw_jobs[:kwargs.get("limit", 25)]:
+            title = (j.get("jobTitle") or j.get("title") or "").strip()
+            company = (j.get("companyName") or j.get("company") or "").strip()
+            url = j.get("url") or j.get("jobURL") or ""
+            desc = (j.get("jobDescription") or j.get("description") or "")[:2000]
+            location = j.get("jobGeo") or j.get("location") or "Remote"
+            salary = j.get("salary") or j.get("salaryRange") or ""
+            remote = "remote" in str(location).lower() or "anywhere" in str(location).lower()
+            tags = j.get("jobIndustry") or j.get("tags") or []
+            if isinstance(tags, str):
+                tags = [t.strip() for t in tags.split(",") if t.strip()]
+
+            job_id = j.get("id") or j.get("jobId") or f"jobicy-{hash(title + company)}"
+            jobs.append(JobListing(
+                job_id=str(job_id),
+                title=title,
+                company=company,
+                url=url,
+                location=location,
+                description=desc,
+                salary=str(salary),
+                source=self.platform_name,
+                remote=remote,
+                tags=tags if isinstance(tags, list) else [str(tags)],
+            ))
+        return jobs