chameleon-cv 0.1.0

package/scripts/job_scanner/parsers/wellfound.py

@@ -0,0 +1,94 @@
+"""Wellfound (AngelList) — 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 WellfoundParser(BaseParser):
+    platform_name = "wellfound"
+    SEARCH_URL = "https://wellfound.com/jobs"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        params = {}
+        if query:
+            params["role"] = query.lower().replace(" ", "-")
+
+        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 (Wellfound is heavy JS)
+        if not jobs and self._browser_available():
+            qs = "&".join(f"{k}={v}" for k, v in params.items()) if params else ""
+            url = f"{self.SEARCH_URL}?{qs}" if qs else self.SEARCH_URL
+            browser_resp = self._browser_get(
+                url, timeout=20,
+                wait_selector="[data-testid*='job'], .styles_jobCard",
+                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=["startup"],
+                    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="(/startup-jobs/[^"]+)"[^>]*>.*?'
+            r'<(?:h[23]|span)[^>]*>([^<]+)</.*?'
+            r'<(?:span|a)[^>]*>([^<]+)</.*?',
+            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://wellfound.com{path}",
+                    location="Remote", remote=True,
+                    tags=["startup"], source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                return

package/scripts/job_scanner/parsers/weworkremotely.py

@@ -0,0 +1,60 @@
+"""We Work Remotely — RSS feed, no auth required."""
+
+from __future__ import annotations
+
+import re
+import xml.etree.ElementTree as ET
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class WeWorkRemotelyParser(BaseParser):
+    platform_name = "weworkremotely"
+    RSS_URL = "https://weworkremotely.com/remote-jobs.rss"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        resp = self._http_get(self.RSS_URL)
+        if resp is None:
+            return []
+
+        try:
+            root = ET.fromstring(resp.text)
+        except Exception:
+            return []
+
+        jobs = []
+        for item in root.findall(".//item")[:limit * 2]:
+            title = item.findtext("title", "")
+            link = item.findtext("link", "")
+            desc = item.findtext("description", "")
+            pub_date = item.findtext("pubDate", "")
+
+            if query and query.lower() not in f"{title} {desc}".lower():
+                continue
+
+            company = ""
+            if ":" in title:
+                parts = title.split(":", 1)
+                company = parts[0].strip()
+                title = parts[1].strip()
+
+            jobs.append(
+                JobListing(
+                    title=title,
+                    company=company,
+                    url=link,
+                    location="Remote",
+                    remote=True,
+                    tags=[],
+                    posted_at=pub_date,
+                    description=self._truncate(self._clean_html(desc)),
+                    source=self.platform_name,
+                )
+            )
+            if len(jobs) >= limit:
+                break
+        return jobs

package/scripts/job_scanner/parsers/ycomb.py

@@ -0,0 +1,83 @@
+"""YC Startup Jobs — scraping-based parser for Y Combinator startups."""
+
+from __future__ import annotations
+
+import httpx
+import re
+
+from ..base import BaseParser, JobListing
+from ..registry import register_parser
+
+
+@register_parser
+class YCombParser(BaseParser):
+    platform_name = "ycomb"
+    BASE_URL = "https://www.ycombinator.com/jobs"
+
+    def fetch_jobs(
+        self, query: str = "", tags: list[str] | None = None, limit: int = 25, **kwargs
+    ) -> list[JobListing]:
+        params = {}
+        if query:
+            params["query"] = query
+
+        try:
+            resp = httpx.get(self.BASE_URL, params=params, timeout=15, follow_redirects=True, headers={
+                "User-Agent": "Mozilla/5.0 (compatible; ChameleonBot/1.0)"
+            })
+            resp.raise_for_status()
+            html = resp.text
+        except Exception:
+            return []
+
+        jobs = []
+        # YC Jobs uses React — look for __NEXT_DATA__ or embedded JSON
+        next_data = re.search(r'<script id="__NEXT_DATA__"[^>]*>(.*?)</script>', html, re.DOTALL)
+        if next_data:
+            import json
+            try:
+                data = json.loads(next_data.group(1))
+                props = data.get("props", {}).get("pageProps", {})
+                job_list = props.get("jobs", props.get("results", []))
+                for item in job_list[:limit]:
+                    jobs.append(
+                        JobListing(
+                            title=item.get("title", item.get("role", "")),
+                            company=item.get("companyName", item.get("company", {}).get("name", "")),
+                            url=f"https://www.ycombinator.com/companies/{item.get('company', {}).get('slug', '')}/jobs/{item.get('slug', item.get('id', ''))}",
+                            location=item.get("location", ""),
+                            remote=item.get("remote", True),
+                            tags=item.get("tags", []),
+                            source=self.platform_name,
+                        )
+                    )
+            except Exception:
+                pass
+
+        # Fallback: HTML scraping
+        if not jobs:
+            card_pattern = re.compile(
+                r'<a[^>]*href="(/companies/[^/]+/jobs/[^"]+)"[^>]*>.*?'
+                r'<(?:span|div)[^>]*>([^<]+)</.*?'
+                r'<(?:span|a)[^>]*href="/companies/([^"]+)"[^>]*>([^<]+)<',
+                re.DOTALL,
+            )
+            for match in card_pattern.finditer(html):
+                job_path, title, company_path, 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.ycombinator.com{job_path}",
+                        location="Remote",
+                        remote=True,
+                        tags=["startup", "yc"],
+                        source=self.platform_name,
+                    )
+                )
+                if len(jobs) >= limit:
+                    break
+
+        return jobs

package/scripts/job_scanner/registry.py

@@ -0,0 +1,65 @@
+"""Parser registry — import all parsers here to auto-register them."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .base import BaseParser
+
+_registry: dict[str, type[BaseParser]] = {}
+
+
+def register_parser(cls: type[BaseParser]) -> type[BaseParser]:
+    """Decorator to register a parser class."""
+    _registry[cls.platform_name] = cls
+    return cls
+
+
+def get_parser(platform: str) -> type[BaseParser] | None:
+    """Get a parser class by platform name."""
+    _ensure_loaded()
+    return _registry.get(platform)
+
+
+def get_all_parsers() -> dict[str, type[BaseParser]]:
+    """Get all registered parsers."""
+    _ensure_loaded()
+    return dict(_registry)
+
+
+def list_platforms() -> list[str]:
+    """List all available platform names."""
+    _ensure_loaded()
+    return sorted(_registry.keys())
+
+
+_loaded = False
+
+def _ensure_loaded():
+    global _loaded
+    if _loaded:
+        return
+    _loaded = True
+    from .parsers import (  # noqa: F401
+        himalayas,
+        remoteok,
+        remotive,
+        weworkremotely,
+        hn_hiring,
+        jobicy,
+        adzuna,
+        jooble,
+        arc,
+        crypto_careers,
+        dailyremote,
+        relocate,
+        web3_career,
+        ycomb,
+        linkedin,
+        indeed,
+        wellfound,
+        flexjobs,
+        opentoworkremote,
+        remote_rocketship,
+    )

package/scripts/job_scanner/scanner.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""
+Chameleon Job Scanner — search jobs across 20 platforms.
+
+Usage:
+    python -m scripts.job_scanner --query "python engineer" --platforms himalayas,remoteok,remotive
+    python -m scripts.job_scanner --query "rust" --all --limit 10
+    python -m scripts.job_scanner --list-platforms
+    echo "python" | python -m scripts.job_scanner --stdin
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import time
+from pathlib import Path
+
+# Ensure the project root is in path
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT))
+
+from scripts.job_scanner.registry import get_all_parsers, list_platforms, get_parser
+from scripts.job_scanner.base import JobListing
+
+# All supported platforms
+ALL_PLATFORMS = [
+    # Tier 1 — Direct API/RSS (most reliable)
+    "himalayas", "remoteok", "remotive", "weworkremotely", "hn_hiring",
+    "jobicy", "adzuna", "jooble",
+    # Tier 2 — Scraping (moderate)
+    "arc", "crypto_careers", "dailyremote", "relocate", "web3_career",
+    "ycomb",
+    # Tier 3 — Hard (anti-bot, limited)
+    "linkedin", "indeed", "wellfound", "flexjobs", "remote_rocketship",
+    # Tier 4 — API key required
+    "opentoworkremote",
+]
+
+TIER_1 = ["himalayas", "remoteok", "remotive", "weworkremotely", "hn_hiring", "jobicy", "adzuna", "jooble"]
+TIER_2 = ["arc", "crypto_careers", "dailyremote", "relocate", "web3_career", "ycomb"]
+
+
+def scan_jobs(
+    query: str = "",
+    platforms: list[str] | None = None,
+    tags: list[str] | None = None,
+    limit: int = 25,
+    use_tier1_only: bool = False,
+    **kwargs,
+) -> list[JobListing]:
+    """Scan jobs across specified platforms and return unified listings."""
+    if platforms is None:
+        platforms = TIER_1 if use_tier1_only else ALL_PLATFORMS
+
+    all_jobs: list[JobListing] = []
+    seen_ids: set[str] = set()
+    errors: list[str] = []
+
+    for platform_name in platforms:
+        parser_cls = get_parser(platform_name)
+        if parser_cls is None:
+            print(f"[warn] Unknown platform: {platform_name}", file=sys.stderr)
+            continue
+
+        parser = parser_cls()
+        try:
+            jobs = parser.fetch_jobs(query=query, tags=tags, limit=limit, **kwargs)
+            for job in jobs:
+                if job.job_id not in seen_ids:
+                    seen_ids.add(job.job_id)
+                    all_jobs.append(job)
+        except Exception as e:
+            errors.append(f"{platform_name}: {e}")
+            print(f"[error] {platform_name}: {e}", file=sys.stderr)
+
+    if errors:
+        print(f"\n[info] {len(errors)} platform(s) had errors", file=sys.stderr)
+
+    return all_jobs
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Chameleon Job Scanner")
+    ap.add_argument("--query", "-q", default="", help="Search query (keywords, role)")
+    ap.add_argument("--platforms", "-p", default="", help="Comma-separated platform names")
+    ap.add_argument("--all", "-a", action="store_true", help="Scan all platforms")
+    ap.add_argument("--tier1", action="store_true", help="Scan only Tier 1 (API/RSS) platforms")
+    ap.add_argument("--limit", "-n", type=int, default=25, help="Max jobs per platform")
+    ap.add_argument("--tags", "-t", default="", help="Comma-separated tags to filter")
+    ap.add_argument("--output", "-o", default="", help="Output JSON file path")
+    ap.add_argument("--list-platforms", "-l", action="store_true", help="List all available platforms")
+    ap.add_argument("--json", "-j", action="store_true", help="Output as JSON")
+
+    args = ap.parse_args()
+
+    if args.list_platforms:
+        for p in list_platforms():
+            tier = "T1" if p in TIER_1 else "T2" if p in TIER_2 else "T3/T4"
+            print(f"  [{tier:4s}] {p}")
+        print(f"\n  Total: {len(list_platforms())} platforms")
+        return
+
+    platforms = None
+    if args.platforms:
+        platforms = [p.strip() for p in args.platforms.split(",")]
+    elif args.all:
+        platforms = ALL_PLATFORMS
+    elif args.tier1:
+        platforms = TIER_1
+
+    tags = [t.strip() for t in args.tags.split(",") if t.strip()] if args.tags else None
+
+    start = time.time()
+    jobs = scan_jobs(
+        query=args.query,
+        platforms=platforms,
+        tags=tags,
+        limit=args.limit,
+    )
+    elapsed = time.time() - start
+
+    if args.json or args.output:
+        data = [j.to_dict() for j in jobs]
+        if args.output:
+            Path(args.output).parent.mkdir(parents=True, exist_ok=True)
+            Path(args.output).write_text(json.dumps(data, indent=2))
+            print(f"Saved {len(data)} jobs to {args.output}", file=sys.stderr)
+        else:
+            print(json.dumps(data, indent=2))
+    else:
+        # Pretty table output
+        if not jobs:
+            print("No jobs found.")
+            return
+
+        print(f"\n{'='*80}")
+        print(f" CHAMELEON JOB SCANNER — {len(jobs)} results ({elapsed:.1f}s)")
+        print(f"{'='*80}\n")
+
+        for i, job in enumerate(jobs, 1):
+            tags_str = ", ".join(job.tags[:5]) if job.tags else ""
+            remote_tag = " [R]" if job.remote else ""
+            salary_tag = f" ${job.salary}" if job.salary else ""
+            print(f"  {i:2}. [{job.source}]{remote_tag}{salary_tag} {job.title}")
+            print(f"      Company: {job.company}")
+            if job.location:
+                print(f"      Location: {job.location}")
+            if tags_str:
+                print(f"      Tags: {tags_str}")
+            print(f"      URL: {job.url}")
+            print()
+
+        print(f"{'='*80}")
+        src_count = len(set(j.source for j in jobs))
+        print(f" Total: {len(jobs)} jobs from {src_count} platforms ({elapsed:.1f}s)")
+        print(f"{'='*80}")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/question.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from scripts.config import config
+
+
+def _opencode_run(prompt: str, timeout_s: int = 120) -> tuple[bool, str]:
+    opencode_bin = config.opencode_bin()
+    if not opencode_bin.exists():
+        return False, f"opencode not found at {opencode_bin}"
+
+    env = {**config.env(), "OPENCODE_CLI_DISABLE_ANIMATION": "true"}
+    chameleon_root = Path(__file__).resolve().parent.parent
+
+    try:
+        proc = subprocess.Popen(
+            [str(opencode_bin), "run", prompt],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
+            cwd=str(chameleon_root), env=env,
+        )
+    except FileNotFoundError:
+        return False, f"opencode binary not executable at {opencode_bin}"
+
+    try:
+        out, err = proc.communicate(timeout=timeout_s)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+        proc.wait(timeout=5)
+        return False, f"opencode timed out after {timeout_s}s"
+    except Exception as e:
+        proc.kill()
+        proc.wait(timeout=5)
+        return False, str(e)
+
+    if proc.returncode != 0:
+        return False, (err or f"opencode exited non-zero ({proc.returncode})").strip()[:200]
+    out = (out or "").strip()
+    if not out:
+        return False, (err or "opencode produced no output").strip()[:200]
+    return True, out
+
+
+QUESTION_PROMPT = """Answer the following job application question in exactly 1 paragraph.
+Write in simple, direct first-person language grounded in the resume and job context provided.
+Answer the question directly in the first sentence.
+Use assertive framing when supported, prefer one strong impact detail over a stack list.
+Do not turn the answer into a cover letter, resume summary, or ATS keyword dump.
+
+## QUESTION
+{question_text}
+
+## JOB DESCRIPTION
+{jd_text}
+
+## RESUME YAML
+{cv_yaml}
+
+Return ONLY the answer paragraph — no greeting, no sign-off, no markdown.
+"""
+
+
+def answer_question(question_text: str, jd_text: str, cv_path: str | Path) -> dict:
+    cv_yaml = Path(cv_path).read_text(encoding="utf-8")
+    prompt = QUESTION_PROMPT.format(
+        question_text=question_text.strip(),
+        jd_text=jd_text.strip() if jd_text else "(not provided)",
+        cv_yaml=cv_yaml,
+    )
+    success, result = _opencode_run(prompt)
+    if success:
+        return {"success": True, "answer": result}
+    return {"success": False, "error": result}
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Answer a screening question from JD + CV")
+    ap.add_argument("question_file", help="Path to file containing the question text")
+    ap.add_argument("--jd", "-j", default=None, help="Path to job description text file (optional)")
+    ap.add_argument("--cv", "-c", default=None, help="Path to CV YAML (default: master CV from config)")
+    ap.add_argument("--json", action="store_true", help="JSON output")
+    args = ap.parse_args()
+
+    question_text = Path(args.question_file).read_text(encoding="utf-8").strip()
+    jd_text = Path(args.jd).read_text(encoding="utf-8") if args.jd else ""
+    cv_path = args.cv or config.master_cv_path()
+
+    result = answer_question(question_text, jd_text, cv_path)
+
+    if args.json:
+        import json
+        print(json.dumps(result, indent=2))
+    else:
+        if result.get("success"):
+            print(result["answer"])
+        else:
+            print(f"Error: {result.get('error', 'unknown')}", file=sys.stderr)
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/render.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Render a RenderCV YAML file to output/, using the venv rendercv binary."""
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+VENV_BIN = ROOT / ".venv" / ("Scripts" if sys.platform == "win32" else "bin")
+RENDERCV = VENV_BIN / ("rendercv.exe" if sys.platform == "win32" else "rendercv")
+
+_ENV = {**{k: str(v) for k, v in (__import__('os').environ).items()},
+        "PYTHONIOENCODING": "utf-8", "TERM": "xterm-256color"}
+
+
+def _find_rendercv() -> Path | None:
+    """Locate the rendercv binary, checking venv, PATH, and user site-packages."""
+    if RENDERCV.exists():
+        return RENDERCV
+    # Check if rendercv is on PATH
+    import shutil as _shutil
+    on_path = _shutil.which("rendercv")
+    if on_path:
+        return Path(on_path)
+    # Check pip user install directory
+    try:
+        import subprocess as _sp
+        r = _sp.run([sys.executable, "-m", "pip", "show", "rendercv"], capture_output=True, text=True)
+        if r.returncode == 0:
+            for line in r.stdout.splitlines():
+                if line.lower().startswith("location:"):
+                    loc = line.split(":", 1)[1].strip()
+                    bin_dir = Path(loc).parent / "Scripts"
+                    exe = bin_dir / "rendercv.exe"
+                    if exe.exists():
+                        return exe
+    except Exception:
+        pass
+    return None
+
+
+def render_yaml(yaml_path: Path) -> tuple[bool, str]:
+    """Render a YAML file to PDF. Returns (success, message_or_pdf_path)."""
+    rendercv = _find_rendercv()
+    if rendercv is None:
+        return False, "rendercv not found. Run: make install-tools"
+
+    output_dir = ROOT / "output"
+    output_dir.mkdir(exist_ok=True)
+
+    stem = yaml_path.stem
+    tmp = ROOT / yaml_path.name
+    shutil.copy2(yaml_path, tmp)
+
+    try:
+        result = subprocess.run(
+            [
+                str(rendercv), "render", str(tmp),
+                "--pdf-path", str(output_dir / f"{stem}.pdf"),
+                "--typst-path", str(output_dir / f"{stem}.typ"),
+                "--markdown-path", str(output_dir / f"{stem}.md"),
+                "--html-path", str(output_dir / f"{stem}.html"),
+            ],
+            check=False,
+            capture_output=True,
+            text=False,  # capture raw bytes to avoid encoding errors
+        )
+        stdout_text = result.stdout.decode("utf-8", errors="replace") if result.stdout else ""
+        stderr_text = result.stderr.decode("utf-8", errors="replace") if result.stderr else ""
+    finally:
+        tmp.unlink(missing_ok=True)
+
+    if result.returncode == 0:
+        return True, _find_output_pdf(output_dir, stem)
+    else:
+        # rendercv sometimes exits non-zero even on success (rich UnicodeError on Windows)
+        pdf = _find_output_pdf(output_dir, stem)
+        if pdf:
+            return True, pdf
+        err = (stderr_text or stdout_text or "unknown error").strip()[:300]
+        return False, err
+
+
+def _find_output_pdf(output_dir: Path, stem: str) -> str | None:
+    """Return only the deterministic artifact for this render invocation."""
+    pdf_path = output_dir / f"{stem}.pdf"
+    return str(pdf_path) if pdf_path.exists() else None
+
+
+def main() -> None:
+    if len(sys.argv) != 2:
+        print("Usage: python scripts/render.py <path-to-yaml>")
+        sys.exit(1)
+
+    source = Path(sys.argv[1].strip())
+    if not source.exists():
+        print(f"Error: {source} not found")
+        sys.exit(1)
+
+    ok, msg = render_yaml(source)
+    if ok:
+        print(f"Rendered: {msg}")
+    else:
+        print(f"Error: {msg}")
+    sys.exit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    main()