katze 0.1.1__py3-none-any.whl

katze/__init__.py

@@ -0,0 +1,4 @@
+"""JobKatze CLI package."""
+
+__version__ = "0.1.0"
+

katze/cli.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from collections.abc import Callable
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from katze import config as cfg
+from katze import shell
+from katze.client import ApiError, JobKatzeClient
+from katze.fill import (
+    create_browser_context,
+    detect_ats_source,
+    extract_dom_questions,
+    open_and_fill_job,
+)
+from katze.letter import (
+    compile_typst_pdf,
+    extract_resume_text,
+    generate_cover_letter,
+    write_and_compile_letter,
+)
+from katze.pickers import browser_login, pick_pdf_via_finder
+from katze.questions import (
+    DIRECT_ATS_SOURCES,
+    harvest_jobs_questions,
+    save_questions,
+)
+
+BRAND_SCHWARZ = "#26211b"
+BRAND_ROT = "#c73e3e"
+BRAND_GOLD = "#d99a06"
+BRAND_GREEN = "#3d7a52"
+BRAND_PAW = "#b98a5e"
+BRAND_MUTED = "#877a68"
+FLAG_STRIPE = f"[{BRAND_SCHWARZ}]━━━━━━━━━[/][{BRAND_ROT}]━━━━━━━━━[/][{BRAND_GOLD}]━━━━━━━━━[/]"
+
+
+def _env_badge(api_url: str) -> str:
+    url_low = (api_url or "").lower()
+    if "localhost" in url_low or "127.0.0.1" in url_low:
+        return f"[{BRAND_GOLD}]● Local Dev[/]"
+    return f"[{BRAND_GREEN}]● Production Cloud[/]"
+
+
+app = typer.Typer(help="JobKatze Auto-Apply TUI (katze)", invoke_without_command=True)
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context):
+    if ctx.invoked_subcommand is None:
+        cfg.ensure_initialized()
+        _launch()
+
+
+def _load_pending_tabs(path: Path) -> list[dict]:
+    if not path.exists():
+        return []
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _save_pending_tabs(path: Path, items: list[dict]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(items, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def _select_jobs(client: JobKatzeClient, from_source: str, source: str, limit: int, job_id: str = "") -> list[dict]:
+    if job_id:
+        return [client.get_job(job_id)]
+    if from_source == "match":
+        effective_source = source or DIRECT_ATS_SOURCES
+        matches = client.match_jobs(source=effective_source, limit=limit)
+        if matches:
+            client.set_applications([j["id"] for j in matches], "saved")
+        return matches[:limit]
+    apps = client.list_applications()
+    saved = [j for j in apps if j.get("application_status") == "saved"]
+    if source:
+        sources = {s.strip().lower() for s in source.split(",") if s.strip()}
+        saved = [j for j in saved if j.get("source", "").lower() in sources]
+    saved.sort(
+        key=lambda j: (
+            j.get("match_score") is not None,
+            j.get("match_score", 0),
+            j.get("application_updated", ""),
+        ),
+        reverse=True,
+    )
+    return saved[:limit]
+
+
+def _job_from_url(client: JobKatzeClient, target_url: str) -> dict:
+    try:
+        imported = client.import_job(target_url)
+        if imported.get("job"):
+            return imported["job"]
+    except Exception:
+        pass
+    src = detect_ats_source(target_url) or "direct"
+    comp = ""
+    m_slug = re.search(r"https?://(?:jobs\.ashbyhq\.com|boards\.greenhouse\.io|jobs\.lever\.co)/([^/?#]+)", target_url)
+    if m_slug:
+        comp = m_slug.group(1).replace("-", " ").capitalize()
+    else:
+        m_sub = re.search(r"https?://([^.]+)\.(?:personio\.(?:de|com)|recruitee\.com)", target_url)
+        if m_sub:
+            comp = m_sub.group(1).replace("-", " ").capitalize()
+    jid = f"custom_{hashlib.sha256(target_url.encode()).hexdigest()[:10]}"
+    return {
+        "id": jid,
+        "url": target_url,
+        "company": comp or "Direct ATS Job",
+        "title": "Position",
+        "source": src,
+        "active": True,
+    }
+
+
+def _apply_core(
+    client: JobKatzeClient,
+    *,
+    target_url: str = "",
+    from_source: str = "saved",
+    source: str = "",
+    limit: int = 5,
+    job_id: str = "",
+    jobs: list[dict] | None = None,
+    regen: bool = False,
+    on_progress: Callable[[dict], None] | None = None,
+) -> str:
+    def _notify(payload: dict) -> None:
+        if on_progress:
+            on_progress(payload)
+
+    base_dir = cfg.get_config_dir()
+    profile = cfg.load_profile()
+    resume_path = cfg.resolve_resume_path()
+    typst_path = base_dir / cfg.TYPST_FILE
+    questions_path = base_dir / cfg.QUESTIONS_FILE
+    pending_path = base_dir / cfg.PENDING_TABS_FILE
+
+    explicit_selection = jobs is not None or bool(job_id) or bool(target_url)
+    if jobs is not None:
+        target_jobs = list(jobs)
+    elif target_url:
+        target_jobs = [_job_from_url(client, target_url)]
+    else:
+        try:
+            target_jobs = _select_jobs(client, from_source=from_source, source=source, limit=limit, job_id=job_id)
+        except ApiError as exc:
+            return f"Failed to load jobs: {exc.message}"
+
+    if not target_jobs:
+        return "No eligible jobs found to apply. Use /match or save jobs on JobKatze."
+
+    _notify({"phase": "connecting to Chrome", "step": 0, "total": len(target_jobs), "label": "Chrome"})
+    context = create_browser_context(base_dir / "chrome-profile")
+
+    resume_text = extract_resume_text(resume_path) if resume_path.exists() else ""
+    opened_sessions = []
+    skipped_inactive = 0
+    pending_by_id = {item["id"]: item for item in _load_pending_tabs(pending_path)}
+
+    for idx, job in enumerate(target_jobs, 1):
+        jid = job["id"]
+        if not explicit_selection and job.get("active") is False:
+            skipped_inactive += 1
+            continue
+        try:
+            full_job = client.get_job(jid) or job
+        except Exception:
+            full_job = job
+        if not full_job.get("id"):
+            full_job["id"] = jid
+
+        label = f"{full_job.get('company', '')} - {full_job.get('title', '')}".strip(" -") or str(jid)
+        _notify({"phase": "writing cover letter", "step": idx, "total": len(target_jobs), "label": label, "job_id": jid})
+
+        _, txt_path, pdf_path = write_and_compile_letter(
+            base_dir,
+            full_job,
+            resume_text,
+            profile,
+            typst_path,
+            regen=regen,
+            generate_fn=generate_cover_letter,
+            compile_fn=compile_typst_pdf,
+        )
+
+        cl_text = txt_path.read_text(encoding="utf-8") if txt_path.exists() else ""
+        _notify({"phase": "opening & filling tab", "step": idx, "total": len(target_jobs), "label": label, "job_id": jid})
+        page, unfilled = open_and_fill_job(
+            context,
+            full_job,
+            profile,
+            resume_path=resume_path,
+            cover_letter_pdf=pdf_path,
+            cover_letter_txt=cl_text,
+        )
+        http_qs = harvest_jobs_questions([full_job], max_workers=1)
+        dom_qs = extract_dom_questions(page, full_job)
+        save_questions(http_qs or dom_qs, questions_path)
+
+        pending_by_id[jid] = {
+            "id": jid,
+            "company": full_job.get("company", ""),
+            "title": full_job.get("title", ""),
+            "source": full_job.get("source", ""),
+            "url": full_job.get("url", ""),
+            "unfilled": unfilled,
+        }
+        opened_sessions.append((full_job, page))
+        _notify(
+            {
+                "phase": "done_one",
+                "step": idx,
+                "total": len(target_jobs),
+                "label": label,
+                "job_id": jid,
+                "unfilled": len(unfilled),
+            }
+        )
+
+    _save_pending_tabs(pending_path, list(pending_by_id.values()))
+    if not opened_sessions and skipped_inactive:
+        return f"No active jobs to open (skipped {skipped_inactive} inactive job(s))."
+    ready_count = sum(1 for j, _ in opened_sessions if not pending_by_id.get(j.get("id", ""), {}).get("unfilled"))
+    needs_count = len(opened_sessions) - ready_count
+    return f"Opened {len(opened_sessions)} tab(s) in Chrome ({ready_count} READY, {needs_count} need review). Run /confirm when submitted."
+
+
+from katze.tui import (
+    IN_TUI_HANDLERS,
+    _banner,
+    _handlers,
+    _launch,
+    _refresh,
+    _status_line,
+    render_screen,
+)

katze/client.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import base64
+from pathlib import Path
+import httpx
+from katze.config import AppConfig
+
+
+class ApiError(Exception):
+    def __init__(self, status_code: int, message: str):
+        super().__init__(f"API error {status_code}: {message}")
+        self.status_code = status_code
+        self.message = message
+
+
+class JobKatzeClient:
+    def __init__(self, config: AppConfig):
+        self.base_url = config.api_url.rstrip("/")
+        self.token = config.token
+
+    def _headers(self) -> dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        return headers
+
+    def _request(self, method: str, path: str, json: dict | None = None, params: dict | None = None) -> dict:
+        url = f"{self.base_url}{path}"
+        with httpx.Client(timeout=30.0) as client:
+            try:
+                resp = client.request(method, url, json=json, params=params, headers=self._headers())
+            except httpx.TransportError:
+                resp = client.request(method, url, json=json, params=params, headers=self._headers())
+        if resp.status_code >= 400:
+            try:
+                err_body = resp.json()
+                msg = err_body.get("error", resp.text)
+            except Exception:
+                msg = resp.text
+            raise ApiError(resp.status_code, msg)
+        return resp.json()
+
+    def login(self, email: str, password: str) -> str:
+        data = self._request("POST", "/auth/login", json={"email": email, "password": password})
+        token = data.get("token", "")
+        self.token = token
+        return token
+
+    def me(self) -> dict:
+        return self._request("GET", "/auth/me")
+
+    def get_job(self, job_id: str) -> dict:
+        return self._request("GET", f"/jobs/{job_id}")
+
+    def list_applications(self) -> list[dict]:
+        data = self._request("GET", "/applications")
+        return data.get("jobs", [])
+
+    def set_application(self, job_id: str, status: str) -> dict:
+        return self._request("POST", "/applications", json={"job_id": job_id, "status": status})
+
+    def set_applications(self, job_ids: list[str], status: str) -> dict:
+        ids = list(dict.fromkeys(str(j) for j in job_ids if j))
+        if not ids:
+            return {"job_ids": [], "status": status, "count": 0}
+        try:
+            return self._request("POST", "/applications", json={"job_ids": ids, "status": status})
+        except ApiError as exc:
+            if exc.status_code == 400 and "job_id" in exc.message:
+                for jid in ids:
+                    self.set_application(jid, status)
+                return {"job_ids": ids, "status": status, "count": len(ids)}
+            raise
+
+    def match_jobs(self, source: str = "", limit: int = 50) -> list[dict]:
+        params = {"limit": str(limit)}
+        if source:
+            params["source"] = source
+        data = self._request("GET", "/match", params=params)
+        return data.get("jobs", [])
+
+    def import_job(self, url: str, company: str = "", title: str = "") -> dict:
+        return self._request(
+            "POST",
+            "/jobs/import",
+            json={"url": url, "company": company, "title": title},
+        )
+
+    def upload_resume(self, path: Path) -> dict:
+        encoded = base64.b64encode(path.read_bytes()).decode("ascii")
+        return self._request(
+            "POST",
+            "/profile/resume",
+            json={"filename": path.name, "content_base64": encoded},
+        )
+
+

katze/config.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import os
+import tomllib
+from dataclasses import asdict, dataclass, fields
+from pathlib import Path
+import yaml
+
+DEFAULT_CONFIG_DIR = Path.home() / ".config" / "jobkatze"
+CONFIG_FILE = "config.toml"
+PROFILE_FILE = "profile.yaml"
+RESUME_FILE = "resume.pdf"
+TYPST_FILE = "letter.typ"
+QUESTIONS_FILE = "questions.jsonl"
+PENDING_TABS_FILE = "pending_tabs.json"
+PROD_API_URL = "https://func-jobkatze-6cdva9lr.azurewebsites.net/api"
+LOCAL_API_URL = "http://localhost:7071/api"
+PROD_FRONTEND_URL = "https://jobkatze.works"
+LOCAL_FRONTEND_URL = "http://localhost:3000"
+
+
+def frontend_url_for(api_url: str) -> str:
+    local = "localhost" in api_url or "127.0.0.1" in api_url
+    return LOCAL_FRONTEND_URL if local else PROD_FRONTEND_URL
+
+
+@dataclass
+class AppConfig:
+    api_url: str = PROD_API_URL
+    token: str = ""
+
+
+@dataclass
+class CandidateProfile:
+    first_name: str = ""
+    last_name: str = ""
+    email: str = ""
+    phone: str = ""
+    city: str = ""
+    country: str = "Germany"
+    linkedin: str = ""
+    github: str = ""
+    website: str = ""
+    eu_work_permit: bool = True
+    requires_sponsorship: bool = False
+    nationality: str = ""
+    work_permit_type: str = ""
+    salary_expectation_eur: int = 0
+    earliest_start: str = ""
+    notice_period: str = "Immediately"
+    german_level: str = "B1"
+    english_level: str = "C2"
+    hybrid_onsite_ok: bool = True
+    residing_in_germany: bool = True
+    willing_to_relocate: bool = True
+    referral_source: str = "Company Website"
+    auto_consent: bool = True
+    gender: str = "Decline to self-identify"
+    pronouns: str = "Prefer not to say"
+    highest_degree: str = "Master's"
+
+    @property
+    def full_name(self) -> str:
+        return f"{self.first_name} {self.last_name}".strip()
+
+    @property
+    def contact_line(self) -> str:
+        parts = [self.email, self.phone, self.city]
+        return " · ".join(p for p in parts if p)
+
+
+def get_config_dir() -> Path:
+    env_dir = os.environ.get("JOBKATZE_CONFIG_DIR")
+    if env_dir:
+        path = Path(env_dir)
+    elif xdg := os.environ.get("XDG_CONFIG_HOME"):
+        path = Path(xdg) / "jobkatze"
+    else:
+        path = Path.home() / ".config" / "jobkatze"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def load_config() -> AppConfig:
+    path = get_config_dir() / CONFIG_FILE
+    if not path.exists():
+        return AppConfig()
+    data = tomllib.loads(path.read_text(encoding="utf-8"))
+    return AppConfig(
+        api_url=data.get("api_url", PROD_API_URL).rstrip("/"),
+        token=data.get("token", ""),
+    )
+
+
+def save_config(config: AppConfig) -> None:
+    path = get_config_dir() / CONFIG_FILE
+    content = f'api_url = "{config.api_url}"\ntoken = "{config.token}"\n'
+    path.write_text(content, encoding="utf-8")
+    path.chmod(0o600)
+
+
+def load_profile() -> CandidateProfile:
+    path = get_config_dir() / PROFILE_FILE
+    if not path.exists():
+        return CandidateProfile()
+    data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    eu_permit = bool(data.get("eu_work_permit", True))
+    return CandidateProfile(
+        first_name=str(data.get("first_name", "")),
+        last_name=str(data.get("last_name", "")),
+        email=str(data.get("email", "")),
+        phone=str(data.get("phone", "")),
+        city=str(data.get("city", "")),
+        country=str(data.get("country", "Germany")),
+        linkedin=str(data.get("linkedin", "")),
+        github=str(data.get("github", "")),
+        website=str(data.get("website", "")),
+        nationality=str(data.get("nationality", "")),
+        work_permit_type=str(data.get("work_permit_type", "")),
+        eu_work_permit=eu_permit,
+        requires_sponsorship=bool(data.get("requires_sponsorship", not eu_permit)),
+        salary_expectation_eur=int(data.get("salary_expectation_eur", 0)),
+        earliest_start=str(data.get("earliest_start", "")),
+        notice_period=str(data.get("notice_period", "Immediately")),
+        german_level=str(data.get("german_level", "B1")),
+        english_level=str(data.get("english_level", "C2")),
+        hybrid_onsite_ok=bool(data.get("hybrid_onsite_ok", True)),
+        residing_in_germany=bool(data.get("residing_in_germany", True)),
+        willing_to_relocate=bool(data.get("willing_to_relocate", True)),
+        referral_source=str(data.get("referral_source", "Company Website")),
+        auto_consent=bool(data.get("auto_consent", True)),
+        gender=str(data.get("gender", "Decline to self-identify")),
+        pronouns=str(data.get("pronouns", "Prefer not to say")),
+        highest_degree=str(data.get("highest_degree", "Master's")),
+    )
+
+
+def profile_field_names() -> list[str]:
+    return [f.name for f in fields(CandidateProfile)]
+
+
+def coerce_profile_value(field_name: str, raw: object) -> object:
+    by_name = {f.name: f for f in fields(CandidateProfile)}
+    if field_name not in by_name:
+        raise KeyError(f"Unknown profile field: {field_name}")
+    ftype = by_name[field_name].type
+    if ftype in (bool, "bool"):
+        if isinstance(raw, bool):
+            return raw
+        val = str(raw).strip().lower()
+        if val in ("1", "true", "yes", "y", "on"):
+            return True
+        if val in ("0", "false", "no", "n", "off"):
+            return False
+        raise ValueError(f"Expected boolean (true/false) for {field_name}, got {raw!r}")
+    if ftype in (int, "int"):
+        return int(str(raw).strip().replace(",", "").replace("_", ""))
+    return str(raw).strip()
+
+
+def save_profile(profile: CandidateProfile, path: Path | None = None) -> Path:
+    target = path or (get_config_dir() / PROFILE_FILE)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(
+        yaml.safe_dump(asdict(profile), sort_keys=False, allow_unicode=True),
+        encoding="utf-8",
+    )
+    return target
+
+
+def resolve_resume_path() -> Path:
+    return get_config_dir() / RESUME_FILE
+
+
+def ensure_initialized(resume: Path | None = None) -> Path:
+    import shutil
+
+    base_dir = get_config_dir()
+    profile_path = base_dir / PROFILE_FILE
+    typst_target = base_dir / TYPST_FILE
+    if resume is not None:
+        shutil.copyfile(resume, base_dir / RESUME_FILE)
+    save_profile_template(profile_path)
+    source_typst = Path(__file__).resolve().parent.parent.parent / ".agents" / "skills" / "cover-letter-generator" / "letter.typ"
+    if source_typst.exists() and not typst_target.exists():
+        shutil.copyfile(source_typst, typst_target)
+    elif not typst_target.exists():
+        typst_target.write_text(
+            '#set page(paper: "a4", margin: 2.5cm)\n#let body = read(sys.inputs.at("body"))\n#par(body)\n',
+            encoding="utf-8",
+        )
+    return base_dir
+
+
+def save_profile_template(path: Path) -> None:
+    template = """first_name: Alex
+last_name: Müller
+email: alex@example.com
+phone: "+49 170 1234567"
+city: Berlin
+country: Germany
+linkedin: https://linkedin.com/in/alexmueller
+github: https://github.com/alexmueller
+website: https://alexmueller.dev
+nationality: German
+work_permit_type: "EU Citizen / Full Work Authorization"
+eu_work_permit: true
+requires_sponsorship: false
+salary_expectation_eur: 85000
+earliest_start: "2026-12-01"
+notice_period: "Immediately"
+german_level: "B1"
+english_level: "C2"
+hybrid_onsite_ok: true
+residing_in_germany: true
+willing_to_relocate: true
+referral_source: "Company Website"
+auto_consent: true
+gender: "Decline to self-identify"
+pronouns: "Prefer not to say"
+highest_degree: "Master's"
+"""
+    if not path.exists():
+        path.write_text(template, encoding="utf-8")