⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

job-application-assistant

lh-kevin@lh-kevin⭐ 11 stars· last commit 2mo ago· 0 open issues

Search for companies actively hiring for a user-specified job title/role, locate their official career pages, run a background/reputation check on companies of interest (financial health, legal/labor disputes, employee reviews across 知乎/企查查/天眼查/小红书/抖音 etc.), tailor resume/cover letter materials to each opening, and assist with filling out application forms on company websites (with human confirmation before final submission). Use this whenever the user asks to find job openings, search for hirin

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 11 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

job-application-assistant

个人求职 AI Skill|适用于 Claude / Codex

English

一句话看懂: 让 AI 帮你发现目标公司 → 投递前做背调 → 谨慎协助填写申请表 → 统一追踪所有投递,而真正的提交始终由你本人确认。

这是一个给个人求职者使用的 Claude / Codex Skill,不是招聘 SaaS。
没有服务器、没有账号体系、没有云同步;你的投递记录保存在本机 JSON 文件中。


30 秒看懂怎么用

1. 把 Skill 装进 Claude / Codex

  • Claude(桌面端 / Web):Settings → Capabilities → Skills,上传本项目文件夹或打包后的 .skill 文件。
  • Claude Code / Codex:把本项目放入对应工具的 skills 目录。

2. 直接告诉它你想找什么岗位

例如:

帮我寻找 AI Agent 开发相关岗位。
先找正在招聘的公司,优先给出官网招聘页;
准备投递前先做公司背景调查;
我确认后再协助填写申请表,并把投递记录加入看板。

3. Skill 按流程帮你推进

找岗位
   ↓
确认目标公司
   ↓
公司背调
   ↓
决定是否继续
   ↓
辅助填写申请表
   ↓
你本人确认提交
   ↓
记录投递 + 后续跟进

你不需要每天重复复制岗位信息、手动整理公司风险、再单独维护 Excel。


它能帮你做什么

能力你得到什么
🔎找岗位按岗位关键词寻找正在招聘的公司,并优先定位公司的官方招聘页
🏢先背调再投递汇总财务健康度、法律/司法风险、员工口碑和社交媒体公开信息
📝谨慎辅助填表使用可见浏览器协助填写常见 ATS 表单,如 Greenhouse、Lever、Workday
📊统一追踪投递集中记录公司、岗位、渠道、状态、风险标签与跟进提醒
🔁避免重复投递投递前检查是否已经申请过同一家公司
🔒数据本地保存无账号、无服务器、无云同步,求职记录保存在你的电脑里

真实输出长这样

投递记录看板

一眼查看所有投递过的公司、当前进度、渠道、更新时间,以及公司背调风险标签。

公司背调报告

在决定是否继续投递或面试之前,把法律/司法风险、员工口碑和社交媒体公开评价集中到一份报告中。

两个页面都是自包含静态 HTML:不需要服务器,每次运行脚本都会根据你的本地数据重新生成。


为什么它不是“一键海投工具”

这个项目刻意保留了人工确认。

  • 不会自动提交申请:每一批真实投递都必须由你明确确认。
  • 不会破解或绕过验证码:遇到 CAPTCHA 会停止并把控制权交还给你。
  • 不会编造简历经历:不会为了“提高匹配度”虚构事实。
  • 不会编造背调结论:背调结果必须有公开来源。
  • 不会无人值守连续海投:流程中保留人工检查节点。

目标不是“投得越多越好”,而是让求职过程更有信息、更可控、更容易持续跟进。


安装

本项目以 Claude Skill 形式组织:

SKILL.md
scripts/
references/

Claude

  1. 打开 Claude。
  2. 进入 Settings → Capabilities → Skills。
  3. 上传项目文件夹,或上传打包后的 .skill 文件。

Claude Code / Codex

按照对应工具的 Skill 目录规范,把本项目放入 skills 目录即可。


Python 依赖

投递追踪和报告生成:

  • scripts/track_applications.py
  • scripts/due_diligence_report.py

只依赖 Python 标准库。

岗位搜索与 ATS 表单辅助需要:

pip install -r requirements.txt
playwright install chromium

只有使用 ats_form_filler.py 时才需要安装 Chromium。


命令行快速体验

# 记录一条投递
python scripts/track_applications.py add \
  --company "Acme Corp" --role "Frontend Engineer" \
  --channel official_site --url "https://acme.com/careers/123" \
  --status submitted

# 检查是否已经投递过
python scripts/track_applications.py check --company "Acme Corp"

# 查看需要跟进的岗位
python scripts/track_applications.py followups --days 7

# 为公司关联背调报告
python scripts/due_diligence_report.py --input acme_findings.json \
  --out acme_report.html --format html

python scripts/track_applications.py diligence \
  --company "Acme Corp" --role "Frontend Engineer" \
  --risk medium --report acme_report.html --summary "1起劳动仲裁判决"

# 生成投递看板
python scripts/track_applications.py dashboard --out dashboard.html

完整命令参数见各脚本自带的 --help 和文件头部说明。


项目工作流与设计说明

完整分步工作流见 SKILL.md。

各模块设计考虑、参考过的开源工具,以及刻意没有采用的自动海投模式,见 references/。


数据与隐私

这是一个个人本地求职工具:

  • 无服务器
  • 无账号体系
  • 无云同步
  • 投递数据保存在本机 JSON
  • 真实提交由用户本人确认

Disclaimer

这是个人效率工具,不构成法律、财务或职业规划建议。

公司背调报告汇总的是公开信息和社交媒体评论。若某条信息会影响你的重要决定,例如具体诉讼、公司注册状态等,请在行动前到权威或一手来源再次核实。

你需要自行遵守与本工具交互的网站服务条款。


License

MIT — see LICENSE.


如果这个项目对你的求职流程有帮助,欢迎 Star、提交 Issue,或者分享你的使用反馈。

// HOW IT'S BUILT

// FILES

19 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • SKILL.md11 KBe632bbd71a05upstream ↗
    ---
    name: job-application-assistant
    description: Search for companies actively hiring for a user-specified job title/role, locate their official career pages, run a background/reputation check on companies of interest (financial health, legal/labor disputes, employee reviews across 知乎/企查查/天眼查/小红书/抖音 etc.), tailor resume/cover letter materials to each opening, and assist with filling out application forms on company websites (with human confirmation before final submission). Use this whenever the user asks to find job openings, search for hiring companies, apply for jobs on company websites, do a job search + apply workflow, mass-apply to positions, check out or vet a company before applying, or mentions "投简历", "找工作", "校招/社招", "海投", "官网投递", "背调", "公司靠谱吗", "员工评价", "劳动仲裁", "帮我投递简历给招xx的公司", even if they don't use the word "skill".
    ---
    
    # Job Application Assistant
    
    Automates the *research and preparation* side of a job search — finding companies
    hiring for a role and getting application materials submission-ready — while
    treating the actual "submit" click as a human-in-the-loop action, since it sends
    data to a third-party system on the user's behalf.
    
    ## Non-negotiable ground rules
    
    1. **Never auto-submit without explicit per-batch confirmation.** Fill the form,
       show the user what will be sent (company, role, resume version, cover letter),
       and only submit after they say go. Confirming once for a batch of N companies
       is fine if the user explicitly asks for that — but always show the list first.
    2. **Prefer the company's own official career page over third-party job boards**
       when both exist — it's usually the more precise/authoritative application
       channel and less likely to be filtered by an aggregator's ATS noise.
    3. **Never try to defeat CAPTCHAs, login walls, or anti-bot checks.** Stop and
       hand control back to the user (or a browser tool that pauses for it) when one
       appears.
    4. **Respect volume.** Don't fire off dozens of applications back-to-back in a
       tight loop — this looks like spam to ATS anti-abuse systems and produces
       low-quality, unreviewed submissions. Batch in small groups (5–10) with review
       checkpoints.
    5. **Never fabricate experience.** Tailoring a resume means re-ordering,
       re-emphasizing, and rewording *real* content to match a JD's keywords — not
       inventing skills or titles the user doesn't have.
    6. **Due-diligence findings must be sourced and balanced.** When reporting
       on a company's reputation/legal risk, attribute claims to where they came
       from, weigh official records (裁判文书网, 国家企业信用信息公示系统) above
       single social-media posts, and don't present one-off complaints as
       settled fact — see `references/company_due_diligence.md`.
    
    ## Workflow
    
    ### Step 0 — Gather inputs
    Ask (or infer from context) if missing:
    - Target job title/role (required) — e.g. "前端工程师", "Product Manager"
    - Location / remote preference
    - Any must-have filters: industry, company size, seniority, salary floor
    - Whether the user has a resume file already (docx/pdf) — if not, offer to help
      draft one first; a tailored resume needs a base to tailor from.
    
    If ambiguous, pick sensible defaults and state them rather than blocking.
    
    ### Step 1 — Find companies + openings
    Run `scripts/search_target_companies.py` (requires network — see script header)
    or, if network tools/connectors are available in this session (web_search,
    a job-board MCP connector), search directly:
    - Query aggregator sources (LinkedIn Jobs, Indeed, 智联招聘/BOSS直聘/拉勾网 as
      regionally appropriate) for `<role> <location>` to build a candidate list of
      companies + specific posting URLs.
    - De-duplicate by company.
    
    Present the candidate list to the user before going further — let them cut
    companies they're not interested in.
    
    ### Step 1.5 — Company due diligence (背调)
    For each company the user wants to proceed with (or upfront for the whole
    shortlist, if the user prefers), pull together public signal on financial
    health, legal risk, and employee sentiment before spending time tailoring
    materials for it. Follow `references/company_due_diligence.md` for the
    per-source query templates (工商/裁判文书, 知乎, 看准网/脉脉, 小红书, 抖音)
    and how to weigh official records vs. social commentary.
    
    Run the searches with `web_search` (or an equivalent tool in this session),
    compile the findings into the JSON shape documented in
    `scripts/due_diligence_report.py`, then run it to produce a report — write
    it into the **same output folder** you'll later put the applications
    dashboard in, so the relative link between them works:
    
        python scripts/due_diligence_report.py --input <company>_findings.json \
            --out <company>_report.html --format html
    
    Then attach a short risk summary to the tracker so it surfaces in the main
    dashboard instead of sitting in a disconnected file:
    
        python scripts/track_applications.py diligence \
            --company "<company>" --role "<role>" \
            --risk low|medium|high --report <company>_report.html \
            --summary "<one-line summary>"
    
    `diligence` creates a minimal tracker record if one doesn't exist yet —
    useful for vetting a company before deciding whether to even apply. The
    dashboard (`track_applications.py dashboard`) then shows a 背调 risk badge
    per row with a link straight to the full report, plus a "高风险公司" count
    in the summary cards — so the two views (all applications, and how risky
    each company looked) live side by side without merging into one bloated
    file.
    
    Surface any red flags (劳动仲裁记录, 失信被执行人, repeated/corroborated
    complaints about unpaid wages or excessive overtime) prominently and let the
    user decide whether to still apply — don't silently filter companies out,
    and don't state unverified social-media claims as settled fact.
    
    ### Step 2 — Find each company's official career page
    For each approved company, run `scripts/find_career_page.py <company_name>`
    to locate `careers.<company>.com` / `<company>.com/careers` / `/jobs` style
    pages, distinguishing it from the aggregator listing found in Step 1.
    Fall back to the aggregator listing only if no official page is found.
    
    ### Step 3 — Tailor materials per company
    Before starting a new company, run
    `scripts/track_applications.py check --company "<name>"` — if there's
    already a record, show the user its status instead of duplicating work
    (mirrors how established auto-apply tools skip already-applied companies).
    
    For each opening:
    - Read the JD (fetch the posting page).
    - If the docx skill is available and the user wants a Word resume, use it to
      produce a tailored version (see `/mnt/skills/public/docx/SKILL.md`) —
      reorder bullet points and adjust the summary to mirror the JD's key
      requirements/keywords, using only the user's real experience.
    - Keep a base resume version untouched; tailored copies go in per-company
      files so the user can compare.
    
    ### Step 4 — Fill the application form
    - Identify the ATS platform behind the career page using
      `references/ats_platforms.md` (Greenhouse/Lever/Workday/SmartRecruiters/
      iCIMS/自建系统 all have recognizable URL or DOM fingerprints).
    - If a browser automation tool is available in this session (e.g. a connected
      browsing MCP), use it to open the form and fill the known fields (name,
      email, phone, resume upload, cover letter, standard EEO/optional questions)
      using `scripts/ats_form_filler.py` as a reference for field-mapping per ATS.
    - If running `scripts/ats_form_filler.py` directly, always let it run with a
      **visible** browser (its default) — never pass `--headless` unless you're
      sure the form has no bot-check. Headless hides any CAPTCHA from the user
      entirely, which just looks like the script hanging. The script detects
      common CAPTCHA/challenge markers and pauses at the terminal for the user
      to solve it by hand in the visible window; it never tries to bypass one.
    - If no browser tool is available, fill and describe the form fields inline
      and hand the user a checklist + direct link to finish manually.
    - **Stop before clicking submit.** Show the filled summary and wait for
      explicit "submit" / "投递" confirmation from the user. Only then re-run
      with `--confirm-submit`.
    
    ### Step 5 — Track results
    After each confirmed submission (or manual completion), log it with
    `scripts/track_applications.py add` — company, role, date, channel (official
    site / aggregator), ATS, status, link, notes. This becomes the running
    record the user can query later:
    - `list [--status ...]` — filtered raw list
    - `stats` — totals by status/channel, this-week count
    - `followups --days N` — submitted applications stale for N+ days, good
      candidates for a polite check-in message
    - `dashboard --out dashboard.html` — self-contained HTML dashboard (summary
      cards + status breakdown + full table, with a 背调 risk badge/link per row
      if due-diligence info was attached in Step 1.5) the user can open in a
      browser; use this whenever they ask to "整理/查看/汇总投递数据" or want an
      overview rather than a raw list
    - `export --out applications.csv` — for opening in Excel/Google Sheets
    
    See `references/similar_projects.md` for the prior art these tracker
    features and the confirm-before-submit / CAPTCHA-handling design were
    checked against.
    
    ## Reference files
    - `references/ats_platforms.md` — how to recognize each major ATS and what
      fields it typically exposes, for building selector-based automation.
    - `scripts/search_target_companies.py` — network search helper (needs an
      environment with internet access; will no-op with a clear error otherwise).
    - `scripts/find_career_page.py` — heuristics for finding the *official*
      careers page vs. an aggregator mirror.
    - `scripts/ats_form_filler.py` — Playwright-based template for filling common
      ATS forms; requires `playwright` installed and a real browser context, and
      always pauses before the final submit action.
    - `scripts/track_applications.py` — CSV/JSON application tracker with
      duplicate-detection, stats, follow-up reminders, and an HTML dashboard.
    - `scripts/due_diligence_report.py` — turns compiled company-background
      findings into a shareable Markdown/HTML report (basic info, legal risk,
      employee/social sentiment, red flags).
    - `references/company_due_diligence.md` — per-source search-query templates
      (知乎/企查查/天眼查/裁判文书网/看准网/小红书/抖音) and how to weigh and
      present what comes back.
    - `references/similar_projects.md` — survey of comparable open-source
      projects and what this skill deliberately borrowed vs. avoided from them.
    
  • README.md6.0 KB0ba88dc77161upstream ↗
    # job-application-assistant
    
    **个人求职 AI Skill|适用于 Claude / Codex**
    
    *[English](README.en.md)*
    
    <p align="center">
      <img src="docs/readme-hero.png" alt="job-application-assistant:个人求职 AI Skill" width="100%">
    </p>
    
    > **一句话看懂:** 让 AI 帮你**发现目标公司 → 投递前做背调 → 谨慎协助填写申请表 → 统一追踪所有投递**,而真正的提交始终由你本人确认。
    
    这是一个给**个人求职者**使用的 Claude / Codex Skill,不是招聘 SaaS。  
    没有服务器、没有账号体系、没有云同步;你的投递记录保存在本机 JSON 文件中。
    
    ---
    
    ## 30 秒看懂怎么用
    
    ### 1. 把 Skill 装进 Claude / Codex
    
    - **Claude(桌面端 / Web)**:`Settings → Capabilities → Skills`,上传本项目文件夹或打包后的 `.skill` 文件。
    - **Claude Code / Codex**:把本项目放入对应工具的 skills 目录。
    
    ### 2. 直接告诉它你想找什么岗位
    
    例如:
    
    ```text
    帮我寻找 AI Agent 开发相关岗位。
    先找正在招聘的公司,优先给出官网招聘页;
    准备投递前先做公司背景调查;
    我确认后再协助填写申请表,并把投递记录加入看板。
    ```
    
    ### 3. Skill 按流程帮你推进
    
    ```text
    找岗位
       ↓
    确认目标公司
       ↓
    公司背调
       ↓
    决定是否继续
       ↓
    辅助填写申请表
       ↓
    你本人确认提交
       ↓
    记录投递 + 后续跟进
    ```
    
    **你不需要每天重复复制岗位信息、手动整理公司风险、再单独维护 Excel。**
    
    ---
    
    ## 它能帮你做什么
    
    |  | 能力 | 你得到什么 |
    |---|---|---|
    | 🔎 | **找岗位** | 按岗位关键词寻找正在招聘的公司,并优先定位公司的**官方招聘页** |
    | 🏢 | **先背调再投递** | 汇总财务健康度、法律/司法风险、员工口碑和社交媒体公开信息 |
    | 📝 | **谨慎辅助填表** | 使用可见浏览器协助填写常见 ATS 表单,如 Greenhouse、Lever、Workday |
    | 📊 | **统一追踪投递** | 集中记录公司、岗位、渠道、状态、风险标签与跟进提醒 |
    | 🔁 | **避免重复投递** | 投递前检查是否已经申请过同一家公司 |
    | 🔒 | **数据本地保存** | 无账号、无服务器、无云同步,求职记录保存在你的电脑里 |
    
    ---
    
    ## 真实输出长这样
    
    ### 投递记录看板
    
    一眼查看所有投递过的公司、当前进度、渠道、更新时间,以及公司背调风险标签。
    
    <p align="center">
      <img src="docs/dashboard-screenshot.png" alt="投递记录看板" width="100%">
    </p>
    
    ### 公司背调报告
    
    在决定是否继续投递或面试之前,把法律/司法风险、员工口碑和社交媒体公开评价集中到一份报告中。
    
    <p align="center">
      <img src="docs/company-report-screenshot.png" alt="公司背景调查报告" width="78%">
    </p>
    
    两个页面都是自包含静态 HTML:不需要服务器,每次运行脚本都会根据你的本地数据重新生成。
    
    ---
    
    ## 为什么它不是“一键海投工具”
    
    这个项目刻意保留了**人工确认**。
    
    - **不会自动提交申请**:每一批真实投递都必须由你明确确认。
    - **不会破解或绕过验证码**:遇到 CAPTCHA 会停止并把控制权交还给你。
    - **不会编造简历经历**:不会为了“提高匹配度”虚构事实。
    - **不会编造背调结论**:背调结果必须有公开来源。
    - **不会无人值守连续海投**:流程中保留人工检查节点。
    
    目标不是“投得越多越好”,而是让求职过程**更有信息、更可控、更容易持续跟进**。
    
    ---
    
    ## 安装
    
    本项目以 **Claude Skill** 形式组织:
    
    ```text
    SKILL.md
    scripts/
    references/
    ```
    
    ### Claude
    
    1. 打开 Claude。
    2. 进入 `Settings → Capabilities → Skills`。
    3. 上传项目文件夹,或上传打包后的 `.skill` 文件。
    
    ### Claude Code / Codex
    
    按照对应工具的 Skill 目录规范,把本项目放入 skills 目录即可。
    
    ---
    
    ## Python 依赖
    
    投递追踪和报告生成:
    
    - `scripts/track_applications.py`
    - `scripts/due_diligence_report.py`
    
    只依赖 Python 标准库。
    
    岗位搜索与 ATS 表单辅助需要:
    
    ```bash
    pip install -r requirements.txt
    playwright install chromium
    ```
    
    只有使用 `ats_form_filler.py` 时才需要安装 Chromium。
    
    ---
    
    ## 命令行快速体验
    
    ```bash
    # 记录一条投递
    python scripts/track_applications.py add \
      --company "Acme Corp" --role "Frontend Engineer" \
      --channel official_site --url "https://acme.com/careers/123" \
      --status submitted
    
    # 检查是否已经投递过
    python scripts/track_applications.py check --company "Acme Corp"
    
    # 查看需要跟进的岗位
    python scripts/track_applications.py followups --days 7
    
    # 为公司关联背调报告
    python scripts/due_diligence_report.py --input acme_findings.json \
      --out acme_report.html --format html
    
    python scripts/track_applications.py diligence \
      --company "Acme Corp" --role "Frontend Engineer" \
      --risk medium --report acme_report.html --summary "1起劳动仲裁判决"
    
    # 生成投递看板
    python scripts/track_applications.py dashboard --out dashboard.html
    ```
    
    完整命令参数见各脚本自带的 `--help` 和文件头部说明。
    
    ---
    
    ## 项目工作流与设计说明
    
    完整分步工作流见 [`SKILL.md`](SKILL.md)。
    
    各模块设计考虑、参考过的开源工具,以及**刻意没有采用的自动海投模式**,见 [`references/`](references/)。
    
    ---
    
    ## 数据与隐私
    
    这是一个**个人本地求职工具**:
    
    - 无服务器
    - 无账号体系
    - 无云同步
    - 投递数据保存在本机 JSON
    - 真实提交由用户本人确认
    
    ---
    
    ## Disclaimer
    
    这是个人效率工具,不构成法律、财务或职业规划建议。
    
    公司背调报告汇总的是公开信息和社交媒体评论。若某条信息会影响你的重要决定,例如具体诉讼、公司注册状态等,请在行动前到权威或一手来源再次核实。
    
    你需要自行遵守与本工具交互的网站服务条款。
    
    ---
    
    ## License
    
    MIT — see [LICENSE](LICENSE).
    
    ---
    
    如果这个项目对你的求职流程有帮助,欢迎 **Star**、提交 **Issue**,或者分享你的使用反馈。
    
  • scripts/ats_form_filler.py10 KB170a61fa15a7upstream ↗
    #!/usr/bin/env python3
    """
    ats_form_filler.py
    
    Playwright-based template for filling common ATS (Applicant Tracking System)
    application forms. This is a REFERENCE IMPLEMENTATION, not a fire-and-forget
    script — ATS forms vary, and this deliberately STOPS before the final submit
    click so a human can review.
    
    Requires:
        pip install playwright --break-system-packages
        playwright install chromium
    
    Usage:
        python ats_form_filler.py \
            --url "https://boards.greenhouse.io/acme/jobs/12345" \
            --ats greenhouse \
            --name "Zhang Wei" --email "[email protected]" --phone "+86 138..." \
            --resume "/path/to/resume.pdf" \
            --cover-letter "/path/to/cover_letter.pdf"
    
    Behavior:
        1. Opens the page in a VISIBLE (headless=False) browser window by
           default — this is required so a human can see and manually solve
           any CAPTCHA/human-verification challenge the site throws up. Running
           headless hides the challenge entirely, which just looks like the
           script "getting stuck" with no way to respond. Pass --headless only
           if you specifically need a headless run and are confident the target
           form has no bot-check (rare).
        2. Detects/confirms the ATS type (or uses --ats if given).
        3. Checks for a CAPTCHA/anti-bot challenge on the page before filling
           anything (reCAPTCHA/hCaptcha iframe, Cloudflare challenge markers).
           If one is found, the script STOPS and waits at the terminal for you
           to solve it by hand in the visible window, then press Enter to
           continue. It never attempts to solve or bypass the challenge itself.
        4. Fills the known field set for that ATS from references/ats_platforms.md.
        5. Uploads resume/cover letter if fields exist.
        6. Takes a screenshot of the filled form and saves it locally.
        7. PAUSES — prints the screenshot path and a summary, and exits WITHOUT
           clicking submit. A human (or the calling agent, after explicit user
           go-ahead) must run the separate `--confirm-submit` pass to finish.
    """
    import argparse
    import sys
    import time
    
    try:
        from playwright.sync_api import sync_playwright
    except ImportError:
        print(
            "Missing dep. Install with:\n"
            "    pip install playwright --break-system-packages\n"
            "    playwright install chromium\n",
            file=sys.stderr,
        )
        sys.exit(1)
    
    
    # Field selector maps per ATS. These are best-effort and DOM structures
    # change over time — verify against the live page and update as needed.
    ATS_FIELD_MAP = {
        "greenhouse": {
            "name_first": "input#first_name",
            "name_last": "input#last_name",
            "email": "input#email",
            "phone": "input#phone",
            "resume_upload": "input[type=file][name='resume']",
            "cover_letter_upload": "input[type=file][name='cover_letter']",
            "submit_button": "input[type=submit], button#submit_app",
        },
        "lever": {
            "name": "input[name='name']",
            "email": "input[name='email']",
            "phone": "input[name='phone']",
            "resume_upload": "input[name='resume']",
            "submit_button": "button[type='submit']",
        },
        "workday": {
            # Workday is a heavily JS-driven multi-step wizard; selectors are
            # highly tenant-specific. Treat this as a starting point only —
            # you will likely need to record actual selectors per company via
            # the browser tool's inspector before this works reliably.
            "name_first": "input[data-automation-id='legalNameSection_firstName']",
            "name_last": "input[data-automation-id='legalNameSection_lastName']",
            "email": "input[data-automation-id='email']",
            "resume_upload": "input[data-automation-id='file-upload-input-ref']",
            "submit_button": "button[data-automation-id='bottom-navigation-next-button']",
        },
    }
    
    
    CAPTCHA_SELECTORS = [
        "iframe[src*='recaptcha']",
        "iframe[title*='recaptcha' i]",
        "iframe[src*='hcaptcha']",
        "div#challenge-form",             # Cloudflare challenge page
        "div.cf-turnstile",               # Cloudflare Turnstile
        "iframe[src*='turnstile']",
    ]
    
    
    def detect_captcha(page) -> bool:
        for selector in CAPTCHA_SELECTORS:
            try:
                if page.locator(selector).count() > 0:
                    return True
            except Exception:  # noqa: BLE001
                continue
        return False
    
    
    def wait_for_manual_captcha_solve(page) -> None:
        """Never attempts to solve or bypass the challenge. Just makes sure a
        human can see it (headless=False is required for this to work) and
        pauses the script until they've dealt with it."""
        print(
            "\n🔒 A CAPTCHA / human-verification challenge was detected on this "
            "page.\nThe browser window is open — please solve it manually there, "
            "then come back to this terminal.\n"
        )
        input("Press Enter here once you've solved it and the page has moved on... ")
    
    
    def detect_ats(url: str) -> str | None:
        if "greenhouse.io" in url:
            return "greenhouse"
        if "lever.co" in url:
            return "lever"
        if "myworkdayjobs.com" in url:
            return "workday"
        return None
    
    
    def fill_form(page, ats: str, args) -> None:
        fields = ATS_FIELD_MAP.get(ats)
        if not fields:
            raise ValueError(
                f"No field map for ATS '{ats}'. Add one to ATS_FIELD_MAP after "
                "inspecting the live form, or fill manually."
            )
    
        def try_fill(selector_key, value):
            selector = fields.get(selector_key)
            if not selector or not value:
                return
            try:
                page.fill(selector, value, timeout=3000)
            except Exception as e:  # noqa: BLE001
                print(f"  (skip) could not fill {selector_key}: {e}", file=sys.stderr)
    
        if "name_first" in fields and args.name:
            first, *rest = args.name.split(" ", 1)
            try_fill("name_first", first)
            if rest:
                try_fill("name_last", rest[0])
        elif "name" in fields:
            try_fill("name", args.name)
    
        try_fill("email", args.email)
        try_fill("phone", args.phone)
    
        if args.resume and fields.get("resume_upload"):
            try:
                page.set_input_files(fields["resume_upload"], args.resume)
            except Exception as e:  # noqa: BLE001
                print(f"  (skip) resume upload failed: {e}", file=sys.stderr)
    
        if args.cover_letter and fields.get("cover_letter_upload"):
            try:
                page.set_input_files(fields["cover_letter_upload"], args.cover_letter)
            except Exception as e:  # noqa: BLE001
                print(f"  (skip) cover letter upload failed: {e}", file=sys.stderr)
    
    
    def main():
        parser = argparse.ArgumentParser(description=__doc__)
        parser.add_argument("--url", required=True)
        parser.add_argument("--ats", default="", help="greenhouse|lever|workday (auto-detected if omitted)")
        parser.add_argument("--name", default="")
        parser.add_argument("--email", default="")
        parser.add_argument("--phone", default="")
        parser.add_argument("--resume", default="")
        parser.add_argument("--cover-letter", default="")
        parser.add_argument("--screenshot-out", default="filled_form.png")
        parser.add_argument(
            "--confirm-submit",
            action="store_true",
            help="Only pass this after the user has explicitly reviewed and "
            "approved the filled form. Without it, the script never clicks submit.",
        )
        parser.add_argument(
            "--headless",
            action="store_true",
            help="Run without a visible window. NOT recommended: if the site "
            "shows a CAPTCHA, a headless run cannot be solved by a human. Only "
            "use this when you're confident the target form has no bot-check.",
        )
        args = parser.parse_args()
    
        ats = args.ats or detect_ats(args.url)
        if not ats:
            print(
                "Could not auto-detect ATS from URL. Pass --ats explicitly, or "
                "check references/ats_platforms.md for fingerprints.",
                file=sys.stderr,
            )
            sys.exit(1)
    
        with sync_playwright() as p:
            browser = p.chromium.launch(headless=args.headless)
            page = browser.new_page()
            page.goto(args.url, timeout=20000)
            time.sleep(1)
    
            if detect_captcha(page):
                if args.headless:
                    print(
                        "CAPTCHA detected but running headless — a human can't "
                        "see it to solve it. Re-run without --headless.",
                        file=sys.stderr,
                    )
                    browser.close()
                    sys.exit(1)
                wait_for_manual_captcha_solve(page)
    
            fill_form(page, ats, args)
    
            # Check again after filling — some forms only trigger the challenge
            # once fields are touched or on attempted submit.
            if detect_captcha(page):
                if args.headless:
                    print(
                        "CAPTCHA appeared after filling, but running headless.",
                        file=sys.stderr,
                    )
                    browser.close()
                    sys.exit(1)
                wait_for_manual_captcha_solve(page)
    
            page.screenshot(path=args.screenshot_out, full_page=True)
            print(f"Filled form screenshot saved to: {args.screenshot_out}")
    
            if args.confirm_submit:
                fields = ATS_FIELD_MAP[ats]
                submit_selector = fields.get("submit_button")
                if not submit_selector:
                    print("No submit selector mapped for this ATS.", file=sys.stderr)
                else:
                    page.click(submit_selector, timeout=5000)
                    time.sleep(2)
                    if detect_captcha(page):
                        print(
                            "CAPTCHA appeared right at submit — solve it manually "
                            "in the window, then check the page yourself to "
                            "confirm whether the application actually went "
                            "through (don't assume success).",
                        )
                        if not args.headless:
                            wait_for_manual_captcha_solve(page)
                    else:
                        print("Submitted.")
            else:
                print(
                    "NOT submitted — review the screenshot, then re-run with "
                    "--confirm-submit once the user explicitly approves."
                )
    
            browser.close()
    
    
    if __name__ == "__main__":
        main()
    
  • scripts/due_diligence_report.py21 KB0adbb896b6dfupstream ↗
    #!/usr/bin/env python3
    """
    due_diligence_report.py
    
    Render a structured company due-diligence report (Markdown or HTML) from
    findings JSON. This script does NOT search the web itself — see
    references/company_due_diligence.md for the query templates. The calling
    agent should run those searches (via web_search or similar), compile what
    it finds into the JSON shape below, then call this script to produce a
    clean, shareable report.
    
    No network required here — purely local formatting, so it works in any
    sandbox including ones without internet access.
    
    Input JSON shape (all fields optional except "company"):
    {
      "company": "Acme Corp",
      "role": "Frontend Engineer",                 // optional, ties it to a specific opening
      "risk": "medium",                             // optional: low|medium|high — shown as a
                                                     // stamp on the report; keep this in sync
                                                     // with the --risk you pass to
                                                     // track_applications.py diligence
      "basic_info": {
        "founded": "2015",
        "registered_capital": "5000万人民币",
        "legal_rep": "张三",
        "funding_stage": "C轮",
        "source": "企查查/天眼查"
      },
      "legal_risks": [
        {"type": "劳动争议判决", "summary": "2023年因未足额支付加班费被判赔偿",
         "source": "中国裁判文书网", "url": "https://...", "date": "2023-06"}
      ],
      "employee_reviews": [
        {"platform": "知乎", "sentiment": "negative",
         "summary": "多位回答提到加班较多,管理层沟通不畅", "url": "https://..."}
      ],
      "social_mentions": [
        {"platform": "小红书", "sentiment": "positive",
         "summary": "多篇入职体验贴反馈团队氛围不错", "url": "https://..."}
      ],
      "red_flags": ["近一年有2起劳动仲裁判决", "股权结构半年内变更3次"],
      "overall_notes": "整体口碑中性偏负面,建议面试时重点确认加班与薪酬发放节奏。"
    }
    
    Usage:
        python due_diligence_report.py --input acme_findings.json --out acme_report.md
        python due_diligence_report.py --input acme_findings.json --out acme_report.html --format html
    """
    import argparse
    import json
    import re
    import sys
    from datetime import datetime
    
    SENTIMENT_LABEL = {
        "positive": "正面 🟢",
        "negative": "负面 🔴",
        "neutral": "中性 ⚪",
    }
    
    
    def load_findings(path: str) -> dict:
        with open(path, "r", encoding="utf-8") as f:
            return json.load(f)
    
    
    def render_markdown(data: dict) -> str:
        company = data.get("company", "未知公司")
        role = data.get("role", "")
        lines = [f"# {company} 背调报告", ""]
        if role:
            lines.append(f"_关联岗位:{role}_")
        lines.append(f"_生成时间:{datetime.now().strftime('%Y-%m-%d %H:%M')}_")
        lines.append("")
        lines.append(
            "> 本报告基于公开信息(工商登记、裁判文书、社交媒体讨论)整理,"
            "仅供参考,不构成法律或财务建议;社交媒体评价为个人观点,"
            "请结合来源权威性自行判断。"
        )
        lines.append("")
    
        red_flags = data.get("red_flags", [])
        if red_flags:
            lines.append("## ⚠️ 重点风险提示")
            for flag in red_flags:
                lines.append(f"- {flag}")
            lines.append("")
    
        basic = data.get("basic_info", {})
        if basic:
            lines.append("## 基本信息")
            for key, label in [
                ("founded", "成立时间"),
                ("registered_capital", "注册资本"),
                ("legal_rep", "法定代表人"),
                ("funding_stage", "融资阶段"),
            ]:
                if basic.get(key):
                    lines.append(f"- **{label}**:{basic[key]}")
            if basic.get("source"):
                lines.append(f"- _数据来源:{basic['source']}_")
            lines.append("")
    
        legal = data.get("legal_risks", [])
        if legal:
            lines.append("## 法律 / 司法风险")
            for item in legal:
                date = f"({item['date']})" if item.get("date") else ""
                lines.append(f"- **{item.get('type','')}**{date}:{item.get('summary','')}")
                if item.get("source") or item.get("url"):
                    src = item.get("source", "")
                    url = item.get("url", "")
                    lines.append(f"  - 来源:{src} {url}".strip())
            lines.append("")
        else:
            lines.append("## 法律 / 司法风险")
            lines.append("未检索到明显司法风险记录(不代表不存在,建议自行到国家企业信用信息公示系统核实)。")
            lines.append("")
    
        reviews = data.get("employee_reviews", [])
        if reviews:
            lines.append("## 员工口碑")
            for item in reviews:
                sentiment = SENTIMENT_LABEL.get(item.get("sentiment", "neutral"), "")
                lines.append(f"- [{item.get('platform','')}] {sentiment} {item.get('summary','')}")
                if item.get("url"):
                    lines.append(f"  - {item['url']}")
            lines.append("")
    
        social = data.get("social_mentions", [])
        if social:
            lines.append("## 社交媒体口碑(小红书/抖音等)")
            lines.append("_注意甄别官方营销内容与真实员工/用户反馈。_")
            for item in social:
                sentiment = SENTIMENT_LABEL.get(item.get("sentiment", "neutral"), "")
                lines.append(f"- [{item.get('platform','')}] {sentiment} {item.get('summary','')}")
                if item.get("url"):
                    lines.append(f"  - {item['url']}")
            lines.append("")
    
        notes = data.get("overall_notes")
        if notes:
            lines.append("## 综合建议")
            lines.append(notes)
            lines.append("")
    
        return "\n".join(lines)
    
    
    def render_html(data: dict) -> str:
        """Rendered as an "Editorial Intelligence" report — approved HTML demo:
        page-b-company-report.html. Serif display type, a prominent risk hero
        (not a small badge), numbered evidence sections, a closing verdict
        block. Same underlying `data` contract as before — only the rendering
        changed."""
        INK, MUTED, LINE, LINE_STRONG = "#101010", "#6E6E68", "#D5D4CE", "#AFAEA7"
        PAPER, PAGE_BG = "#FAFAF7", "#EDEDE9"
        RED, RED_SOFT, GREEN = "#B94335", "#F1DEDA", "#315C47"
        AMBER = "#8B6C1A"
        MONO = '"Cascadia Code","SFMono-Regular",Consolas,"Liberation Mono",monospace'
        SANS = 'Inter,"Segoe UI","PingFang SC","Microsoft YaHei",Arial,sans-serif'
        SERIF = '"Noto Serif SC","Source Han Serif SC","Songti SC",Georgia,serif'
    
        RISK_COLORS = {"low": GREEN, "medium": AMBER, "high": RED}
        RISK_SOFT = {"low": "#DDE7E0", "medium": "#EEE4CF", "high": RED_SOFT}
        RISK_LABEL_EN = {"low": "LOW", "medium": "MEDIUM", "high": "HIGH"}
        RISK_LABEL_ZH = {"low": "低", "medium": "中", "high": "高"}
        # Derived decision label from the risk field — a display transform of
        # existing data, not a new fact. No risk => no decision block (nothing
        # to derive it from).
        DECISION = {
            "low": ("PROCEED", "建议:可按正常节奏推进。"),
            "medium": ("PROCEED WITH CAUTION", "建议:可继续推进,但需重点核实下方红旗提示中的问题。"),
            "high": ("RECONSIDER", "建议:谨慎对待,最好先获得更多信息确认后再决定是否继续。"),
        }
        SENTIMENT_LABEL_EN = {"positive": "POSITIVE", "negative": "NEGATIVE", "neutral": "NEUTRAL"}
        SENTIMENT_CLASS = {"positive": "", "negative": "negative", "neutral": ""}
    
        company = data.get("company", "未知公司")
        role = data.get("role", "")
        risk = data.get("risk", "")
    
        def esc(s):
            return str(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
    
        # Risk hero — the report's single most important visual element.
        riskbox_html = ""
        if risk in RISK_COLORS:
            n_legal = len(data.get("legal_risks", []))
            n_red_flags = len(data.get("red_flags", []))
            n_negative = sum(
                1 for i in data.get("employee_reviews", []) + data.get("social_mentions", [])
                if i.get("sentiment") == "negative"
            )
            basis_parts = []
            if n_red_flags:
                basis_parts.append(f"{n_red_flags} 条重点风险提示")
            if n_legal:
                basis_parts.append(f"{n_legal} 条法律/司法记录")
            if n_negative:
                basis_parts.append(f"{n_negative} 条负面口碑")
            basis = "、".join(basis_parts) if basis_parts else "以下公开信息"
            riskbox_html = f'''<aside class="riskbox">
          <div class="label">OVERALL RISK</div>
          <div class="risk" style="color:{RISK_COLORS[risk]}">{RISK_LABEL_EN[risk]}</div>
          <div class="cn">综合风险:{RISK_LABEL_ZH[risk]}</div>
          <p>本判断基于{esc(basis)}综合得出,详见下方各节证据;请结合来源权威性自行判断,不作为最终结论。</p>
        </aside>'''
    
        # Red flags — existing field from before this UI pass. The approved
        # demo doesn't have an explicit slot for this, so it's folded into the
        # risk-hero basis text above AND kept as its own compact list here
        # (styled with the demo's own .tag language) so no data is dropped.
        red_flags = data.get("red_flags", [])
        red_flags_html = ""
        if red_flags:
            tags = "".join(f'<span class="tag high" style="margin:0 8px 8px 0;">{esc(f)}</span>' for f in red_flags)
            red_flags_html = f'<div class="disclaimer" style="border-top:none;"><div style="font:800 10px/1.2 {MONO};letter-spacing:.1em;color:{MUTED};text-transform:uppercase;margin-bottom:10px;">重点风险提示</div>{tags}</div>'
    
        # Lede / executive note — derived from the first sentence of
        # overall_notes (real data), not a separately-invented field.
        lede_html = ""
        notes = data.get("overall_notes", "")
        if notes:
            first_sentence = re.split(r"(?<=[。!])", notes.strip())[0]
            lede_html = f'''<section class="lede">
          <div class="index">EXECUTIVE NOTE</div>
          <p>{esc(first_sentence)}</p>
        </section>'''
    
        def section(num, tag, title, inner):
            return f'''<section class="section">
          <div class="section-num">{num}<span>{tag}</span></div>
          <div>
            <h2>{title}</h2>
            {inner}
          </div>
        </section>'''
    
        # 01 — basic info facts grid
        basic = data.get("basic_info", {})
        fact_defs = [
            ("founded", "Founded"), ("registered_capital", "Registered Capital"),
            ("legal_rep", "Legal Representative"), ("funding_stage", "Funding"),
        ]
        facts = [(label, basic[key]) for key, label in fact_defs if basic.get(key)]
        basic_section = ""
        if facts:
            facts_html = "".join(
                f'<div class="fact"><div class="k">{esc(k)}</div><div class="v">{esc(v)}</div></div>'
                for k, v in facts
            )
            source_note = (
                f'<div class="muted" style="font:600 11px/1.4 {MONO};margin-top:10px;">数据来源:{esc(basic["source"])}</div>'
                if basic.get("source") else ""
            )
            basic_section = section("01", "THE COMPANY", "基本信息", f'<div class="facts">{facts_html}</div>{source_note}')
    
        # 02 — legal / judicial risk signals
        legal = data.get("legal_risks", [])
        if legal:
            signal_rows = []
            for item in legal:
                src = ""
                if item.get("url"):
                    src = f'<div class="source"><a href="{esc(item["url"])}" target="_blank">{esc(item.get("source","SOURCE"))} ↗</a></div>'
                elif item.get("source"):
                    src = f'<div class="source">{esc(item["source"])}</div>'
                signal_rows.append(f'''<div class="signal">
            <div class="tagwrap"><span class="tag high">RISK</span></div>
            <div class="date">{esc(item.get("date","—"))}</div>
            <div class="summary"><h3>{esc(item.get("type",""))}</h3><p>{esc(item.get("summary",""))}</p></div>
            {src}
          </div>''')
            legal_inner = "\n".join(signal_rows)
        else:
            legal_inner = '<p class="muted">未检索到明显司法风险记录(不代表不存在,建议自行到国家企业信用信息公示系统核实)。</p>'
        legal_section = section("02", "LEGAL SIGNALS", "法律与司法风险", legal_inner)
    
        def quote_block(item):
            sentiment = item.get("sentiment", "neutral")
            link = f'<a href="{esc(item["url"])}" target="_blank">查看原文 ↗</a>' if item.get("url") else ""
            return f'''<div class="quote">
            <div class="source-line"><span>{esc(item.get("platform",""))}</span>
            <span class="sentiment {SENTIMENT_CLASS.get(sentiment,"")}">{SENTIMENT_LABEL_EN.get(sentiment,"")}</span></div>
            <blockquote>{esc(item.get("summary",""))}</blockquote>
            <div class="source-line"><span class="muted">摘要来自公开来源,需注意个体样本偏差。</span>{link}</div>
          </div>'''
    
        reviews = data.get("employee_reviews", [])
        reviews_section = ""
        if reviews:
            reviews_section = section("03", "EMPLOYEE VOICE", "员工口碑", "\n".join(quote_block(i) for i in reviews))
    
        social = data.get("social_mentions", [])
        social_section = ""
        if social:
            social_section = section("04", "SOCIAL SIGNALS", "社交媒体口碑", "\n".join(quote_block(i) for i in social))
    
        # Verdict — uses the real overall_notes field; decision block derived
        # from the risk field (hidden if no risk was provided, since there's
        # nothing to derive it from).
        verdict_html = ""
        if notes or risk in DECISION:
            decision_html = ""
            if risk in DECISION:
                big, small = DECISION[risk]
                decision_html = f'<div class="decision"><div class="big" style="color:{RISK_COLORS[risk]}">{big}</div><div class="small">{esc(small)}</div></div>'
            verdict_html = f'''<section class="verdict">
          <div>
            <div class="kicker">THE VERDICT</div>
            <h2>综合建议</h2>
            <p>{esc(notes) if notes else "暂无综合建议,请结合以上信息自行判断。"}</p>
          </div>
          {decision_html}
        </section>'''
    
        return f"""<!doctype html>
    <html lang="zh-CN">
    <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>{esc(company)} — 公司背调报告</title>
    <style>
    :root{{
      --paper:{PAPER}; --ink:{INK}; --muted:{MUTED}; --line:{LINE}; --line-strong:{LINE_STRONG};
      --red:{RED}; --red-soft:{RED_SOFT}; --green:{GREEN};
      --mono:{MONO}; --sans:{SANS}; --serif:{SERIF};
    }}
    *{{box-sizing:border-box}}
    html{{background:{PAGE_BG};color:var(--ink)}}
    body{{margin:0;font-family:var(--sans);background:{PAGE_BG}}}
    a{{color:inherit;text-decoration:none;border-bottom:1px solid currentColor}}
    .page{{max-width:1180px;margin:26px auto;background:var(--paper);min-height:100vh;padding:38px 54px 72px;box-shadow:0 8px 30px rgba(0,0,0,.04)}}
    .masthead{{display:flex;justify-content:space-between;gap:24px;border-bottom:2px solid var(--ink);padding-bottom:16px}}
    .brand{{font:800 12px/1 var(--mono);letter-spacing:.15em;text-transform:uppercase}}
    .issue{{text-align:right;font:600 11px/1.55 var(--mono);color:var(--muted)}}
    .hero{{display:grid;grid-template-columns:1.6fr .8fr;gap:42px;padding:42px 0 34px;border-bottom:1px solid var(--line-strong)}}
    .kicker{{font:800 11px/1 var(--mono);letter-spacing:.13em;color:var(--muted);text-transform:uppercase;margin-bottom:18px}}
    h1{{font-family:var(--serif);font-size:54px;line-height:1.04;letter-spacing:-.045em;margin:0;max-width:720px}}
    .subhead{{font-size:16px;color:var(--muted);margin-top:16px}}
    .riskbox{{align-self:start;border:1px solid var(--ink);padding:18px 20px 20px;position:sticky;top:24px}}
    .riskbox .label{{font:800 10px/1 var(--mono);letter-spacing:.12em;color:var(--muted)}}
    .riskbox .risk{{font:800 50px/.95 var(--mono);letter-spacing:-.05em;margin-top:18px}}
    .riskbox .cn{{font-family:var(--serif);font-weight:700;font-size:22px;margin-top:8px}}
    .riskbox p{{font-size:12px;line-height:1.65;color:var(--muted);margin:20px 0 0;padding-top:14px;border-top:1px solid var(--line)}}
    .disclaimer{{padding:13px 0;border-bottom:1px solid var(--line);font-size:12px;color:var(--muted);line-height:1.6}}
    .lede{{display:grid;grid-template-columns:160px 1fr;gap:28px;padding:34px 0 6px}}
    .lede .index{{font:800 12px/1 var(--mono);letter-spacing:.08em}}
    .lede p{{font-family:var(--serif);font-size:23px;line-height:1.6;margin:0;max-width:760px}}
    .section{{display:grid;grid-template-columns:160px 1fr;gap:28px;padding:40px 0;border-top:1px solid var(--line-strong)}}
    .section-num{{font:800 34px/1 var(--mono);letter-spacing:-.05em}}
    .section-num span{{display:block;font:800 10px/1.3 var(--mono);letter-spacing:.12em;color:var(--muted);margin-top:8px}}
    .section h2{{font-family:var(--serif);font-size:32px;line-height:1.1;margin:0 0 22px;letter-spacing:-.025em}}
    .muted{{color:var(--muted)}}
    .facts{{display:grid;grid-template-columns:repeat(4,1fr);border-top:1px solid var(--ink);border-bottom:1px solid var(--ink)}}
    .fact{{padding:18px 16px;border-right:1px solid var(--line)}}.fact:last-child{{border-right:0}}
    .fact .k{{font:800 10px/1.2 var(--mono);letter-spacing:.08em;color:var(--muted);text-transform:uppercase}}
    .fact .v{{font-family:var(--serif);font-size:22px;margin-top:10px}}
    .signal{{display:grid;grid-template-columns:110px 100px 1fr 140px;gap:16px;padding:18px 0;border-top:1px solid var(--line);align-items:start}}
    .signal:first-of-type{{border-top:1px solid var(--ink)}}
    .tag{{font:800 10px/1 var(--mono);padding:5px 6px;border:1px solid currentColor;display:inline-block}}
    .tag.high{{color:var(--red);background:var(--red-soft)}}
    .signal .date{{font:700 11px/1.4 var(--mono);color:var(--muted)}}
    .signal h3{{font-size:14px;margin:0 0 6px}}
    .signal p{{font-size:13px;line-height:1.7;color:#3D3D39;margin:0}}
    .source{{font:800 10px/1.2 var(--mono);text-align:right}}
    .source a{{border-bottom:0}}.source a:hover{{text-decoration:underline}}
    .quote{{padding:24px 0;border-top:1px solid var(--ink)}}.quote:first-of-type{{border-top:0}}
    .quote .source-line{{display:flex;justify-content:space-between;gap:16px;font:800 10px/1.3 var(--mono);letter-spacing:.05em;color:var(--muted)}}
    .quote blockquote{{font-family:var(--serif);font-size:19px;line-height:1.7;margin:16px 0 10px}}
    .sentiment{{font:800 10px/1 var(--mono)}}.sentiment.negative{{color:var(--red)}}
    .verdict{{display:grid;grid-template-columns:1fr 220px;gap:28px;background:#EFEFEA;border-top:2px solid var(--ink);padding:28px 30px}}
    .verdict h2{{margin:0 0 14px}}.verdict p{{font-family:var(--serif);font-size:19px;line-height:1.75;margin:0}}
    .decision{{border-left:1px solid var(--line-strong);padding-left:22px}}
    .decision .big{{font:800 26px/1.15 var(--mono)}}
    .decision .small{{font-size:12px;color:var(--muted);line-height:1.6;margin-top:12px}}
    .footer{{display:flex;justify-content:space-between;gap:18px;padding-top:24px;margin-top:44px;border-top:1px solid var(--ink);font:600 10px/1.5 var(--mono);color:var(--muted)}}
    @media (max-width:860px){{
      .page{{margin:0;padding:28px 20px 52px}}
      .hero{{grid-template-columns:1fr}}
      .riskbox{{position:static}}
      .lede,.section{{grid-template-columns:1fr}}
      .lede .index{{margin-bottom:-12px}}
      .facts{{grid-template-columns:repeat(2,1fr)}}
      .fact:nth-child(2){{border-right:0}}
      .fact:nth-child(-n+2){{border-bottom:1px solid var(--line)}}
      .signal{{grid-template-columns:90px 1fr}}
      .signal .date{{grid-column:1/2}}.signal .summary{{grid-column:2/3}}
      .signal .source{{grid-column:2/3;text-align:left}}.signal .tagwrap{{grid-column:1/2}}
      .verdict{{grid-template-columns:1fr}}
      .decision{{border-left:0;border-top:1px solid var(--line-strong);padding:18px 0 0}}
      .footer{{flex-direction:column}}h1{{font-size:42px}}
    }}
    </style>
    </head>
    <body>
    <article class="page">
      <header class="masthead">
        <div class="brand">Job Application Assistant / Company Intelligence</div>
        <div class="issue">生成时间 {datetime.now().strftime('%Y.%m.%d / %H:%M')}<br>PERSONAL RESEARCH FILE</div>
      </header>
    
      <section class="hero">
        <div>
          <div class="kicker">Company Background Report</div>
          <h1>{esc(company)}</h1>
          {f'<div class="subhead">关联岗位:{esc(role)}</div>' if role else ''}
        </div>
        {riskbox_html}
      </section>
    
      <div class="disclaimer">免责声明:本报告基于公开来源与平台信息汇总,仅用于个人求职决策参考,不构成法律、财务或投资建议。公开信息可能存在延迟、缺失或上下文不完整。</div>
      {red_flags_html}
      {lede_html}
      {basic_section}
      {legal_section}
      {reviews_section}
      {social_section}
      {verdict_html}
    
      <footer class="footer"><span>PERSONAL USE ONLY · PUBLIC-SOURCE RESEARCH</span><span>JOB-APPLICATION-ASSISTANT / COMPANY DOSSIER</span></footer>
    </article>
    </body>
    </html>"""
    
    
    def main():
        parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
        parser.add_argument("--input", required=True, help="Path to findings JSON")
        parser.add_argument("--out", required=True, help="Output file path")
        parser.add_argument("--format", choices=["markdown", "html"], default="markdown")
        args = parser.parse_args()
    
        try:
            data = load_findings(args.input)
        except FileNotFoundError:
            print(f"Input file not found: {args.input}", file=sys.stderr)
            sys.exit(1)
        except json.JSONDecodeError as e:
            print(f"Invalid JSON in {args.input}: {e}", file=sys.stderr)
            sys.exit(1)
    
        if not data.get("company"):
            print("Findings JSON must include a 'company' field.", file=sys.stderr)
            sys.exit(1)
    
        content = render_html(data) if args.format == "html" else render_markdown(data)
        with open(args.out, "w", encoding="utf-8") as f:
            f.write(content)
        print(f"Report written to {args.out}")
    
    
    if __name__ == "__main__":
        main()
    
  • scripts/find_career_page.py4.9 KB60b7ad817fafupstream ↗
    #!/usr/bin/env python3
    """
    find_career_page.py
    
    Given a company name, try to find its OFFICIAL careers/jobs page (as opposed
    to a third-party aggregator mirror of the same listing). REQUIRES NETWORK.
    
    Usage:
        python find_career_page.py "Acme Corp"
        python find_career_page.py "Acme Corp" --homepage https://acme.com
    
    Strategy:
    1. If a homepage URL isn't given, search for "<company> official site" and
       take the top plausible result (heuristic: domain looks like the company
       name, not a news/wiki/social aggregator).
    2. Probe common careers paths on that domain (/careers, /jobs, /about/careers,
       /careers/jobs, /en/careers, etc).
    3. Also check for well-known ATS subdomains (boards.greenhouse.io/<company>,
       jobs.lever.co/<company>, <company>.wd1.myworkdayjobs.com, etc) since many
       companies host applications there while *linking* from their own domain —
       that's still their official channel, just hosted by a vendor.
    4. Return the first working candidate with a confidence note; return all
       candidates checked so the user/agent can pick if the top one is wrong.
    """
    import argparse
    import sys
    from urllib.parse import urlparse
    
    try:
        import requests
    except ImportError:
        print(
            "Missing deps. Install with: pip install requests --break-system-packages",
            file=sys.stderr,
        )
        sys.exit(1)
    
    HEADERS = {"User-Agent": "Mozilla/5.0 (compatible; job-application-assistant/1.0)"}
    TIMEOUT = 8
    
    COMMON_CAREER_PATHS = [
        "/careers",
        "/jobs",
        "/about/careers",
        "/company/careers",
        "/en/careers",
        "/careers/jobs",
        "/join-us",
        "/work-with-us",
        "/zh/careers",
        "/about-us/careers",
    ]
    
    ATS_SUBDOMAIN_PATTERNS = [
        "https://boards.greenhouse.io/{slug}",
        "https://jobs.lever.co/{slug}",
        "https://{slug}.wd1.myworkdayjobs.com",
        "https://{slug}.wd5.myworkdayjobs.com",
        "https://apply.workable.com/{slug}",
        "https://{slug}.bamboohr.com/jobs",
        "https://{slug}.recruitee.com",
    ]
    
    
    def slugify(name: str) -> str:
        return "".join(c.lower() for c in name if c.isalnum())
    
    
    def probe(url: str) -> bool:
        try:
            resp = requests.head(
                url, headers=HEADERS, timeout=TIMEOUT, allow_redirects=True
            )
            if resp.status_code == 405:  # some servers reject HEAD
                resp = requests.get(url, headers=HEADERS, timeout=TIMEOUT)
            return resp.status_code < 400
        except requests.RequestException:
            return False
    
    
    def guess_homepage(company: str) -> str | None:
        """
        Best-effort: try the obvious <slug>.com first. For a robust answer,
        prefer resolving this via a real web_search tool in the calling agent
        (e.g. Claude's web_search) and passing --homepage explicitly — this
        local guess is only a fallback.
        """
        slug = slugify(company)
        for tld in (".com", ".io", ".ai", ".co"):
            candidate = f"https://www.{slug}{tld}"
            if probe(candidate):
                return candidate
        return None
    
    
    def find_career_candidates(homepage: str, company: str) -> list[dict]:
        candidates = []
        domain = urlparse(homepage).netloc
        for path in COMMON_CAREER_PATHS:
            url = f"https://{domain}{path}"
            if probe(url):
                candidates.append(
                    {"url": url, "confidence": "high", "reason": "on company domain"}
                )
    
        slug = slugify(company)
        for pattern in ATS_SUBDOMAIN_PATTERNS:
            url = pattern.format(slug=slug)
            if probe(url):
                candidates.append(
                    {
                        "url": url,
                        "confidence": "medium",
                        "reason": "known ATS vendor, guessed slug — verify it's this company",
                    }
                )
        return candidates
    
    
    def main():
        parser = argparse.ArgumentParser(description=__doc__)
        parser.add_argument("company", help="Company name")
        parser.add_argument(
            "--homepage",
            default="",
            help="Known homepage URL (skip guessing). Recommended: resolve this "
            "via a real search tool first for accuracy.",
        )
        args = parser.parse_args()
    
        homepage = args.homepage or guess_homepage(args.company)
        if not homepage:
            print(
                f"Could not guess a homepage for '{args.company}'. "
                "Pass --homepage explicitly after finding it via web search.",
                file=sys.stderr,
            )
            sys.exit(1)
    
        print(f"Homepage: {homepage}")
        candidates = find_career_candidates(homepage, args.company)
        if not candidates:
            print("No careers page found via common paths or known ATS vendors.")
            print(
                "Fall back to: (1) the aggregator listing found earlier, or "
                "(2) a manual web_search for '<company> careers official site'."
            )
            return
    
        print("Candidate career pages (best first):")
        for c in candidates:
            print(f"  [{c['confidence']}] {c['url']}  ({c['reason']})")
    
    
    if __name__ == "__main__":
        main()
    
  • scripts/search_target_companies.py7.4 KB5b22ac1f6a86upstream ↗
    #!/usr/bin/env python3
    """
    search_target_companies.py
    
    Search job aggregators for companies currently hiring for a given role, and
    return a deduplicated list of {company, title, location, posting_url, source}.
    
    REQUIRES NETWORK ACCESS. This sandbox has network disabled for bash_tool, so
    this script is written for the *user's own* Claude Code / Codex environment
    (or any environment with outbound internet). If run here it will fail fast
    with a clear message rather than hanging.
    
    Usage:
        python search_target_companies.py "前端工程师" --location "上海" --limit 30
        python search_target_companies.py "Product Manager" --location "Remote" \
            --sources linkedin,indeed
    
    Design notes:
    - This does NOT scrape logged-in-only pages or bypass any paywall/CAPTCHA.
      Every source below has a public search results page usable without login;
      if a site changes its markup or starts requiring login, that source will
      simply return zero results and should be swapped for an official API where
      one exists (e.g. GitHub Jobs-style feeds, greenhouse.io's public job board
      JSON endpoints, a licensed job-board API key, etc).
    - Prefer official APIs over HTML scraping wherever the target site offers one
      (Greenhouse's `boards-api.greenhouse.io/v1/boards/<token>/jobs` is a good
      example of a clean, ToS-friendly public endpoint).
    """
    import argparse
    import json
    import sys
    import time
    from dataclasses import dataclass, asdict
    from urllib.parse import quote
    
    try:
        import requests
        from bs4 import BeautifulSoup
    except ImportError:
        print(
            "Missing deps. Install with:\n"
            "    pip install requests beautifulsoup4 --break-system-packages\n",
            file=sys.stderr,
        )
        sys.exit(1)
    
    
    HEADERS = {
        "User-Agent": (
            "Mozilla/5.0 (compatible; job-application-assistant/1.0; "
            "+for personal job-search use)"
        )
    }
    TIMEOUT = 10
    
    
    @dataclass
    class Posting:
        company: str
        title: str
        location: str
        posting_url: str
        source: str
    
    
    def _get(url, params=None):
        resp = requests.get(url, headers=HEADERS, params=params, timeout=TIMEOUT)
        resp.raise_for_status()
        return resp
    
    
    def search_indeed(role: str, location: str, limit: int) -> list[Posting]:
        """Public Indeed search results page (no login required)."""
        out: list[Posting] = []
        try:
            url = "https://www.indeed.com/jobs"
            resp = _get(url, params={"q": role, "l": location})
            soup = BeautifulSoup(resp.text, "html.parser")
            cards = soup.select("div.job_seen_beacon") or soup.select(
                "a.tapItem"
            )
            for card in cards[:limit]:
                company_el = card.select_one(".companyName")
                title_el = card.select_one("h2.jobTitle span") or card.select_one(
                    ".jobTitle"
                )
                loc_el = card.select_one(".companyLocation")
                link_el = card.select_one("a")
                if not (company_el and title_el and link_el):
                    continue
                href = link_el.get("href", "")
                full_url = (
                    href if href.startswith("http") else f"https://www.indeed.com{href}"
                )
                out.append(
                    Posting(
                        company=company_el.get_text(strip=True),
                        title=title_el.get_text(strip=True),
                        location=loc_el.get_text(strip=True) if loc_el else location,
                        posting_url=full_url,
                        source="indeed",
                    )
                )
        except Exception as e:  # noqa: BLE001
            print(f"[indeed] search failed: {e}", file=sys.stderr)
        return out
    
    
    def search_linkedin(role: str, location: str, limit: int) -> list[Posting]:
        """
        LinkedIn's public job-search guest endpoint. LinkedIn aggressively rate
        limits / blocks scraping — treat this as best-effort, low-volume, and
        switch to LinkedIn's official Talent/Jobs API if you need reliability.
        """
        out: list[Posting] = []
        try:
            url = "https://www.linkedin.com/jobs-guest/jobs/api/seeMoreJobPostings/search"
            resp = _get(
                url,
                params={
                    "keywords": role,
                    "location": location,
                    "start": 0,
                },
            )
            soup = BeautifulSoup(resp.text, "html.parser")
            cards = soup.select("li")
            for card in cards[:limit]:
                title_el = card.select_one(".base-search-card__title")
                company_el = card.select_one(".base-search-card__subtitle")
                loc_el = card.select_one(".job-search-card__location")
                link_el = card.select_one("a.base-card__full-link")
                if not (title_el and company_el and link_el):
                    continue
                out.append(
                    Posting(
                        company=company_el.get_text(strip=True),
                        title=title_el.get_text(strip=True),
                        location=loc_el.get_text(strip=True) if loc_el else location,
                        posting_url=link_el.get("href", "").split("?")[0],
                        source="linkedin",
                    )
                )
        except Exception as e:  # noqa: BLE001
            print(f"[linkedin] search failed: {e}", file=sys.stderr)
        return out
    
    
    def search_zhaopin_cn(role: str, location: str, limit: int) -> list[Posting]:
        """
        Placeholder for a China-focused source (智联招聘 / 猎聘 / BOSS直聘).
        These sites require signed API params or app-only endpoints and change
        frequently, so wire this up against whichever one you have legitimate
        API access to, or use their official open-platform APIs if available.
        """
        print(
            "[zhaopin_cn] not implemented — plug in an official API "
            "(e.g. 智联招聘开放平台) or a licensed job-board data provider here.",
            file=sys.stderr,
        )
        return []
    
    
    SOURCES = {
        "indeed": search_indeed,
        "linkedin": search_linkedin,
        "zhaopin_cn": search_zhaopin_cn,
    }
    
    
    def dedupe(postings: list[Posting]) -> list[Posting]:
        seen = set()
        result = []
        for p in postings:
            key = (p.company.strip().lower(), p.title.strip().lower())
            if key in seen:
                continue
            seen.add(key)
            result.append(p)
        return result
    
    
    def main():
        parser = argparse.ArgumentParser(description=__doc__)
        parser.add_argument("role", help="Job title/role to search for")
        parser.add_argument("--location", default="", help="City / 'Remote' / etc.")
        parser.add_argument("--limit", type=int, default=25, help="Max results per source")
        parser.add_argument(
            "--sources",
            default="indeed,linkedin",
            help="Comma-separated source list: " + ",".join(SOURCES.keys()),
        )
        parser.add_argument("--out", default="", help="Write JSON results to this file")
        args = parser.parse_args()
    
        all_postings: list[Posting] = []
        for name in args.sources.split(","):
            name = name.strip()
            fn = SOURCES.get(name)
            if not fn:
                print(f"Unknown source: {name}", file=sys.stderr)
                continue
            all_postings.extend(fn(args.role, args.location, args.limit))
            time.sleep(1)  # be polite between sources
    
        all_postings = dedupe(all_postings)
    
        payload = [asdict(p) for p in all_postings]
        text = json.dumps(payload, ensure_ascii=False, indent=2)
        if args.out:
            with open(args.out, "w", encoding="utf-8") as f:
                f.write(text)
            print(f"Wrote {len(payload)} postings to {args.out}")
        else:
            print(text)
    
    
    if __name__ == "__main__":
        main()
    
  • scripts/track_applications.py24 KBb21544e37070upstream ↗
    #!/usr/bin/env python3
    """
    track_applications.py
    
    Local tracker for job applications — no network required. Stores records in
    a JSON file (default: ./applications.json). No cloud upload, no account
    needed: everything stays on the user's machine (same privacy stance as most
    open-source job-apply tools — see references/similar_projects.md).
    
    Usage:
        # Add/update a record (adding an existing company+role updates it and
        # warns you it's a duplicate, so you don't double-apply by accident)
        python track_applications.py add \
            --company "Acme Corp" --role "Frontend Engineer" \
            --channel official_site --ats greenhouse \
            --url "https://boards.greenhouse.io/acme/jobs/12345" \
            --status submitted
    
        # List everything / filter by status
        python track_applications.py list
        python track_applications.py list --status pending
    
        # Quick summary counts (by status / channel / this week)
        python track_applications.py stats
    
        # Which submitted applications have had no status change in N days
        # (a candidate for a follow-up email)
        python track_applications.py followups --days 10
    
        # Self-contained HTML dashboard you can open in a browser
        python track_applications.py dashboard --out dashboard.html
    
        # Export to CSV (e.g. to import into Google Sheets/Excel)
        python track_applications.py export --out applications.csv
    
        # Check before applying whether you already have a record for a company
        # (mirrors the "skip already-applied companies" pattern from
        # Auto_job_applier_linkedIn)
        python track_applications.py check --company "Acme Corp"
    
        # Attach a due-diligence finding (from due_diligence_report.py) to a
        # company's record so it shows up as a risk badge + link in the
        # dashboard, instead of living in a separate, disconnected file
        python track_applications.py diligence \
            --company "Acme Corp" --role "Frontend Engineer" \
            --risk medium --report acme_report.html \
            --summary "1起劳动仲裁判决,知乎评价偏负面,小红书入职体验尚可"
    """
    import argparse
    import csv
    import json
    import os
    import sys
    from collections import Counter
    from datetime import datetime, timezone, timedelta
    
    DB_PATH_DEFAULT = "applications.json"
    
    STATUS_ORDER = ["pending", "filled", "submitted", "interview", "offer", "rejected"]
    
    # Design tokens — sourced directly from the approved HTML demo
    # (page-a-applications.html / page-b-company-report.html). These are now
    # the visual source of truth; see SKILL.md / this file's cmd_dashboard()
    # docstring for the design brief.
    BG = "#F2F2EF"
    PANEL = "#F8F8F5"
    INK = "#161616"
    MUTED = "#6F706B"
    LINE = "#CBCBC5"
    LINE_STRONG = "#AFAFA8"
    GREEN = "#315C47"
    GREEN_SOFT = "#DDE7E0"
    RED = "#B94335"
    RED_SOFT = "#F1DEDA"
    AMBER = "#9B6B20"
    AMBER_SOFT = "#EEE4CF"
    BLUE = "#34506E"
    BLUE_SOFT = "#DEE6ED"
    MONO = '"Cascadia Code","SFMono-Regular",Consolas,"Liberation Mono",monospace'
    SANS = 'Inter,"Segoe UI","PingFang SC","Microsoft YaHei",Arial,sans-serif'
    
    STATUS_COLORS = {
        "pending": MUTED,
        "filled": BLUE,
        "submitted": GREEN,
        "interview": BLUE,
        "offer": GREEN,
        "rejected": "#777777",
    }
    STATUS_LABEL_ZH = {
        "pending": "待处理",
        "filled": "已填表",
        "submitted": "已投递",
        "interview": "面试中",
        "offer": "已获Offer",
        "rejected": "已拒绝",
    }
    RISK_COLORS = {"low": GREEN, "medium": AMBER, "high": RED}
    RISK_SOFT = {"low": GREEN_SOFT, "medium": AMBER_SOFT, "high": RED_SOFT}
    RISK_LABEL_ZH = {"low": "低风险", "medium": "中风险", "high": "高风险"}
    RISK_LABEL_EN = {"low": "LOW", "medium": "MED", "high": "HIGH"}
    
    
    def load_db(path: str) -> list[dict]:
        if not os.path.exists(path):
            return []
        with open(path, "r", encoding="utf-8") as f:
            return json.load(f)
    
    
    def save_db(path: str, records: list[dict]) -> None:
        with open(path, "w", encoding="utf-8") as f:
            json.dump(records, f, ensure_ascii=False, indent=2)
    
    
    def _key(company: str, role: str) -> tuple[str, str]:
        return (company.strip().lower(), role.strip().lower())
    
    
    def cmd_add(args):
        records = load_db(args.db)
        key_fields = _key(args.company, args.role)
        for r in records:
            if _key(r["company"], r["role"]) == key_fields:
                print(
                    f"⚠️  Duplicate: you already have a record for "
                    f"{r['company']} / {r['role']} (current status: {r.get('status')})."
                    f" Updating it instead of creating a new one."
                )
                r.update(
                    {
                        "channel": args.channel or r.get("channel"),
                        "ats": args.ats or r.get("ats"),
                        "url": args.url or r.get("url"),
                        "status": args.status or r.get("status"),
                        "notes": args.notes or r.get("notes", ""),
                        "updated_at": datetime.now(timezone.utc).isoformat(),
                    }
                )
                save_db(args.db, records)
                print(f"Updated existing record for {args.company} / {args.role}")
                return
    
        now = datetime.now(timezone.utc).isoformat()
        records.append(
            {
                "company": args.company,
                "role": args.role,
                "channel": args.channel,
                "ats": args.ats,
                "url": args.url,
                "status": args.status or "pending",
                "notes": args.notes,
                "created_at": now,
                "updated_at": now,
            }
        )
        save_db(args.db, records)
        print(f"Added record for {args.company} / {args.role}")
    
    
    def cmd_check(args):
        """Look up whether a company already has a record — call this before
        starting a new application to avoid re-applying to the same company."""
        records = load_db(args.db)
        matches = [
            r for r in records if args.company.strip().lower() in r["company"].strip().lower()
        ]
        if not matches:
            print(f"No existing record for '{args.company}' — clear to apply.")
            return
        print(f"Found {len(matches)} existing record(s) for '{args.company}':")
        for r in matches:
            print(f"  - {r['role']}  [{r.get('status')}]  {r.get('url','')}")
    
    
    def cmd_diligence(args):
        """Attach a due-diligence summary (produced by due_diligence_report.py)
        to an existing company/role record so the dashboard can show a risk
        badge + link instead of leaving the report as a disconnected file. If
        no matching record exists yet, creates a minimal one — useful when
        you're vetting a company before deciding to apply at all."""
        records = load_db(args.db)
        key_fields = _key(args.company, args.role)
        now = datetime.now(timezone.utc).isoformat()
        due_diligence = {
            "risk": args.risk,
            "report": args.report,
            "summary": args.summary,
            "checked_at": now,
        }
        for r in records:
            if _key(r["company"], r["role"]) == key_fields:
                r["due_diligence"] = due_diligence
                r["updated_at"] = now
                save_db(args.db, records)
                print(f"Attached due-diligence info to {args.company} / {args.role}")
                return
    
        records.append(
            {
                "company": args.company,
                "role": args.role,
                "channel": "",
                "ats": "",
                "url": "",
                "status": "pending",
                "notes": "",
                "created_at": now,
                "updated_at": now,
                "due_diligence": due_diligence,
            }
        )
        save_db(args.db, records)
        print(
            f"No existing record for {args.company} / {args.role} — created one "
            f"with the due-diligence info attached."
        )
    
    
    def cmd_list(args):
        records = load_db(args.db)
        if args.status:
            records = [r for r in records if r.get("status") == args.status]
        if not records:
            print("No matching records.")
            return
        for r in records:
            print(
                f"- [{r.get('status','?'):10}] {r['company']:<25} {r['role']:<30} "
                f"({r.get('channel','?')}/{r.get('ats','-')})  {r.get('url','')}"
            )
    
    
    def cmd_stats(args):
        records = load_db(args.db)
        if not records:
            print("No records yet.")
            return
    
        total = len(records)
        by_status = Counter(r.get("status", "unknown") for r in records)
        by_channel = Counter(r.get("channel", "unknown") or "unknown" for r in records)
    
        one_week_ago = datetime.now(timezone.utc) - timedelta(days=7)
        this_week = sum(
            1
            for r in records
            if _parse_dt(r.get("created_at")) and _parse_dt(r.get("created_at")) >= one_week_ago
        )
    
        print(f"Total applications tracked: {total}")
        print(f"Added in the last 7 days:   {this_week}")
        print("\nBy status:")
        for status in STATUS_ORDER:
            if by_status.get(status):
                print(f"  {status:10} {by_status[status]}")
        for status, count in by_status.items():
            if status not in STATUS_ORDER:
                print(f"  {status:10} {count}")
        print("\nBy channel:")
        for channel, count in by_channel.most_common():
            print(f"  {channel:15} {count}")
    
    
    def _parse_dt(s):
        if not s:
            return None
        try:
            return datetime.fromisoformat(s)
        except ValueError:
            return None
    
    
    def _stale_submitted(records, days):
        """Shared by cmd_followups (CLI) and cmd_dashboard (follow-up notice bar)
        so the "needs a follow-up" rule lives in exactly one place."""
        cutoff = datetime.now(timezone.utc) - timedelta(days=days)
        stale = []
        for r in records:
            if r.get("status") != "submitted":
                continue
            updated = _parse_dt(r.get("updated_at"))
            if updated and updated <= cutoff:
                days_ago = (datetime.now(timezone.utc) - updated).days
                stale.append((days_ago, r))
        stale.sort(reverse=True)
        return stale
    
    
    def cmd_followups(args):
        """Applications in 'submitted' status that haven't been updated in
        --days days — good candidates for a polite follow-up message."""
        records = load_db(args.db)
        stale = _stale_submitted(records, args.days)
        if not stale:
            print(f"No submitted applications older than {args.days} days without an update.")
            return
        print(f"Applications with no update for {args.days}+ days (follow-up candidates):")
        for days_ago, r in stale:
            print(f"  - {r['company']} / {r['role']}  ({days_ago} days ago)  {r.get('url','')}")
    
    
    def cmd_export(args):
        records = load_db(args.db)
        if not records:
            print("Nothing to export.")
            return
        fields = [
            "company",
            "role",
            "channel",
            "ats",
            "url",
            "status",
            "notes",
            "created_at",
            "updated_at",
        ]
        with open(args.out, "w", newline="", encoding="utf-8-sig") as f:
            writer = csv.DictWriter(f, fieldnames=fields)
            writer.writeheader()
            for r in records:
                writer.writerow({k: r.get(k, "") for k in fields})
        print(f"Exported {len(records)} records to {args.out}")
    
    
    def cmd_dashboard(args):
        """Self-contained HTML dashboard — "Personal Job Ops Console" visual
        direction (approved HTML demo: page-a-applications.html). Industrial/
        terminal feel: horizontal metric strip (not KPI cards), dense scannable
        rows, monospace for numbers/labels, hairline borders only. No JS
        framework, no network calls — open directly in a browser.
    
        Data contract is unchanged from the previous version — this function
        only changes how the same `records` are rendered.
        """
        records = load_db(args.db)
        total = len(records)
        by_status = Counter(r.get("status", "unknown") for r in records)
        high_risk = sum(
            1 for r in records if (r.get("due_diligence") or {}).get("risk") == "high"
        )
        one_week_ago = datetime.now(timezone.utc) - timedelta(days=7)
        this_week = sum(
            1 for r in records
            if _parse_dt(r.get("created_at")) and _parse_dt(r.get("created_at")) >= one_week_ago
        )
        followups = _stale_submitted(records, 7)
    
        def esc(s):
            return str(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
    
        def fmt_date(iso):
            dt = _parse_dt(iso)
            return dt.strftime("%Y.%m.%d") if dt else "—"
    
        def metric(value, label, extra_class="", delta=""):
            delta_html = f'<div class="delta">{esc(delta)}</div>' if delta else ""
            return (
                f'<div class="metric {extra_class}"><div class="value">{value:02d}</div>'
                f'<div class="label">{esc(label)}</div>{delta_html}</div>'
            )
    
        metrics_html = (
            metric(total, "总投递数 / ALL APPLICATIONS", "primary", f"+{this_week} THIS WEEK" if this_week else "")
            + metric(by_status.get("pending", 0), "待处理")
            + metric(by_status.get("submitted", 0), "已投递")
            + metric(by_status.get("interview", 0), "面试中")
            + metric(by_status.get("offer", 0), "已获 Offer")
            + metric(by_status.get("rejected", 0), "已拒绝")
            + metric(this_week, "本周新增")
            + metric(high_risk, "高风险公司", "risk")
        )
    
        notice_html = ""
        if followups:
            notice_html = (
                '<div class="notice"><div><strong>FOLLOW-UP SIGNAL</strong> '
                f'有 <strong>{len(followups)}</strong> 个岗位超过 7 天没有更新,'
                "建议今天检查是否需要跟进。</div>"
                '<div class="hint">RULE / NO UPDATE ≥ 7 DAYS</div></div>'
            )
    
        def row_html(r):
            status = r.get("status", "pending")
            status_label = STATUS_LABEL_ZH.get(status, status)
            status_css = {
                "pending": "pending", "submitted": "applied", "interview": "interview",
                "offer": "offer", "rejected": "rejected", "filled": "pending",
            }.get(status, "pending")
    
            dd = r.get("due_diligence")
            if dd and dd.get("risk") in RISK_COLORS:
                risk = dd["risk"]
                title_attr = f' title="{esc(dd.get("summary",""))}"' if dd.get("summary") else ""
                risk_html = f'<span class="risk {risk}"{title_attr}>{RISK_LABEL_EN[risk]}</span>'
            else:
                risk_html = '<span class="risk none">—</span>'
    
            report = (dd or {}).get("report")
            report_link = (
                f'<a class="icon-link" href="{esc(report)}" target="_blank" title="背调报告">R</a>'
                if report else ""
            )
            job_link = (
                f'<a class="icon-link" href="{esc(r.get("url",""))}" target="_blank" title="职位链接">↗</a>'
                if r.get("url") else ""
            )
    
            return f'''<article class="row">
          <div class="cell"><span class="status {status_css}"><span class="dot"></span>{status_label}</span></div>
          <div class="cell"><div class="company">{esc(r["company"])}</div><div class="role">{esc(r["role"])}</div></div>
          <div class="cell channel">{esc(r.get("channel","") or "—")}</div>
          <div class="cell">{risk_html}</div>
          <div class="cell date created">{fmt_date(r.get("created_at"))}</div>
          <div class="cell date">{fmt_date(r.get("updated_at"))}</div>
          <div class="cell links">{job_link}{report_link}</div>
        </article>'''
    
        ordered = sorted(records, key=lambda r: r.get("updated_at", ""), reverse=True)
        rows_html = "\n".join(row_html(r) for r in ordered)
        body_html = (
            rows_html if records
            else '<p class="empty">还没有记录。用 <code>track_applications.py add</code> 添加第一条投递。</p>'
        )
    
        year, week, _ = datetime.now().isocalendar()
    
        html = f"""<!doctype html>
    <html lang="zh-CN">
    <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>投递记录看板</title>
    <style>
    :root{{
      --bg:{BG}; --panel:{PANEL}; --ink:{INK}; --muted:{MUTED};
      --line:{LINE}; --line-strong:{LINE_STRONG};
      --green:{GREEN}; --green-soft:{GREEN_SOFT};
      --red:{RED}; --red-soft:{RED_SOFT};
      --amber:{AMBER}; --amber-soft:{AMBER_SOFT};
      --blue:{BLUE}; --blue-soft:{BLUE_SOFT};
      --mono:{MONO}; --sans:{SANS};
    }}
    *{{box-sizing:border-box}}
    html{{background:var(--bg);color:var(--ink);font-family:var(--sans)}}
    body{{margin:0;min-height:100vh;background:var(--bg)}}
    a{{color:inherit;text-decoration:none}}
    code{{font-family:var(--mono)}}
    .shell{{max-width:1440px;margin:0 auto;padding:30px 34px 54px}}
    .topbar{{display:flex;justify-content:space-between;align-items:flex-start;gap:20px;border-bottom:1px solid var(--line-strong);padding-bottom:18px}}
    .eyebrow{{font:700 11px/1.2 var(--mono);letter-spacing:.14em;color:var(--muted);text-transform:uppercase}}
    h1{{font-size:34px;line-height:1.05;letter-spacing:-.035em;margin:9px 0 0;font-weight:700}}
    .top-meta{{text-align:right;font:600 12px/1.5 var(--mono);color:var(--muted)}}
    .metrics{{display:grid;grid-template-columns:1.4fr repeat(7,minmax(96px,1fr));border-bottom:1px solid var(--line-strong)}}
    .metric{{min-height:112px;padding:22px 18px;border-right:1px solid var(--line)}}
    .metric:first-child{{padding-left:0}}.metric:last-child{{border-right:0}}
    .metric .value{{font:700 31px/1 var(--mono);letter-spacing:-.04em}}
    .metric.primary .value{{font-size:48px}}
    .metric .label{{font-size:12px;color:var(--muted);margin-top:10px}}
    .metric .delta{{font:700 11px/1.3 var(--mono);margin-top:8px;color:var(--green)}}
    .metric.risk .value{{color:var(--red)}}
    .notice{{display:flex;justify-content:space-between;align-items:center;gap:16px;padding:14px 0;border-bottom:1px solid var(--line);font-size:13px}}
    .notice strong{{font-weight:700}}
    .notice .hint{{font:600 11px/1.4 var(--mono);color:var(--muted)}}
    .list-head{{display:grid;grid-template-columns:110px 1.7fr 1.1fr 100px 100px 130px 92px;padding:14px 0 10px;border-bottom:1px solid var(--line-strong);font:700 10px/1.2 var(--mono);letter-spacing:.09em;color:var(--muted);text-transform:uppercase}}
    .row{{display:grid;grid-template-columns:110px 1.7fr 1.1fr 100px 100px 130px 92px;align-items:center;min-height:86px;border-bottom:1px solid var(--line);position:relative;transition:.16s ease}}
    .row:hover{{background:#EDEDE8;box-shadow:inset 3px 0 0 var(--ink)}}
    .cell{{padding:14px 12px 14px 0;min-width:0}}
    .company{{font-weight:720;font-size:15px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}}
    .role{{font-size:12px;color:var(--muted);margin-top:5px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}}
    .status{{display:inline-flex;align-items:center;gap:7px;font:700 11px/1 var(--mono);white-space:nowrap}}
    .dot{{width:7px;height:7px;border:1px solid currentColor;border-radius:50%}}
    .status.interview{{color:var(--blue)}}.status.applied{{color:var(--green)}}
    .status.pending{{color:var(--muted)}}.status.offer{{color:var(--green)}}.status.rejected{{color:#777}}
    .risk{{display:inline-block;padding:5px 7px;border:1px solid currentColor;font:700 10px/1 var(--mono);letter-spacing:.04em}}
    .risk.high{{color:var(--red);background:var(--red-soft)}}
    .risk.medium{{color:var(--amber);background:var(--amber-soft)}}
    .risk.low{{color:var(--green);background:var(--green-soft)}}
    .risk.none{{color:var(--muted);background:transparent}}
    .channel{{font-size:12px}}
    .date{{font:600 11px/1.3 var(--mono);color:var(--muted)}}
    .links{{display:flex;justify-content:flex-end;gap:7px}}
    .icon-link{{width:30px;height:30px;border:1px solid var(--line-strong);display:grid;place-items:center;font:700 12px/1 var(--mono)}}
    .icon-link:hover{{border-color:var(--ink);background:var(--ink);color:#fff}}
    .empty{{padding:40px 0;color:var(--muted);font-size:13px}}
    .footer{{display:flex;justify-content:space-between;gap:20px;padding-top:18px;font:600 10px/1.5 var(--mono);color:var(--muted)}}
    @media (max-width:1100px){{
      .metrics{{grid-template-columns:repeat(4,1fr)}}
      .metric:first-child{{padding-left:18px}}
      .metric{{border-bottom:1px solid var(--line)}}
      .list-head{{display:none}}
      .row{{grid-template-columns:100px 1.5fr 1fr 90px 90px 92px}}
      .row .created{{display:none}}
    }}
    @media (max-width:760px){{
      .shell{{padding:22px 16px 40px}}
      .topbar{{flex-direction:column}}
      .top-meta{{text-align:left}}
      .metrics{{grid-template-columns:repeat(2,1fr)}}
      .metric.primary .value{{font-size:40px}}
      .notice{{align-items:flex-start;flex-direction:column}}
      .row{{display:grid;grid-template-columns:1fr 84px;gap:0;padding:12px 0}}
      .row .cell{{padding:5px 10px 5px 0}}
      .row .cell:nth-child(1){{grid-column:1/2}}
      .row .cell:nth-child(2){{grid-column:1/2}}
      .row .cell:nth-child(3){{grid-column:1/2}}
      .row .cell:nth-child(4),.row .cell:nth-child(5),.row .cell:nth-child(6){{display:none}}
      .row .links{{grid-column:2/3;grid-row:1/4;align-self:center}}
      .footer{{flex-direction:column}}
    }}
    </style>
    </head>
    <body>
    <main class="shell">
      <header class="topbar">
        <div>
          <div class="eyebrow">Job Application Assistant / Personal Job Ops</div>
          <h1>投递记录看板</h1>
        </div>
        <div class="top-meta">
          {year} / WEEK {week:02d}<br>生成时间 {datetime.now().strftime('%m.%d · %H:%M')}
        </div>
      </header>
    
      <section class="metrics" aria-label="投递概览">
        {metrics_html}
      </section>
    
      {notice_html}
    
      <section>
        <div class="list-head">
          <div>STATUS</div><div>COMPANY / ROLE</div><div>CHANNEL</div><div>RISK</div><div>CREATED</div><div>UPDATED</div><div style="text-align:right">LINKS</div>
        </div>
        {body_html}
      </section>
    
      <footer class="footer">
        <span>PERSONAL USE ONLY · APPLICATION LEDGER</span>
        <span>{total} RECORDS · 数据仅保存在本地,不上传任何服务器</span>
      </footer>
    </main>
    </body>
    </html>"""
    
        with open(args.out, "w", encoding="utf-8") as f:
            f.write(html)
        print(f"Dashboard written to {args.out} — open it in a browser.")
    
    
    def main():
        parser = argparse.ArgumentParser(description=__doc__)
        parser.add_argument("--db", default=DB_PATH_DEFAULT, help="Path to JSON store")
        sub = parser.add_subparsers(dest="cmd", required=True)
    
        p_add = sub.add_parser("add")
        p_add.add_argument("--company", required=True)
        p_add.add_argument("--role", required=True)
        p_add.add_argument("--channel", default="", help="official_site | aggregator")
        p_add.add_argument("--ats", default="")
        p_add.add_argument("--url", default="")
        p_add.add_argument("--notes", default="")
        p_add.add_argument(
            "--status", default="pending", help="pending|filled|submitted|interview|offer|rejected"
        )
        p_add.set_defaults(func=cmd_add)
    
        p_check = sub.add_parser("check", help="Check if a company already has a record before applying")
        p_check.add_argument("--company", required=True)
        p_check.set_defaults(func=cmd_check)
    
        p_diligence = sub.add_parser(
            "diligence", help="Attach a due-diligence risk summary + report link to a record"
        )
        p_diligence.add_argument("--company", required=True)
        p_diligence.add_argument("--role", required=True)
        p_diligence.add_argument(
            "--risk", required=True, choices=["low", "medium", "high"], help="Overall risk level"
        )
        p_diligence.add_argument(
            "--report", default="", help="Path to the report file from due_diligence_report.py "
            "(relative to the dashboard's output folder, so the link works when opened)"
        )
        p_diligence.add_argument("--summary", default="", help="One-line summary shown as a tooltip")
        p_diligence.set_defaults(func=cmd_diligence)
    
        p_list = sub.add_parser("list")
        p_list.add_argument("--status", default="")
        p_list.set_defaults(func=cmd_list)
    
        p_stats = sub.add_parser("stats", help="Summary counts by status/channel/this week")
        p_stats.set_defaults(func=cmd_stats)
    
        p_followups = sub.add_parser("followups", help="Submitted applications with no update in N days")
        p_followups.add_argument("--days", type=int, default=10)
        p_followups.set_defaults(func=cmd_followups)
    
        p_dashboard = sub.add_parser("dashboard", help="Generate a self-contained HTML dashboard")
        p_dashboard.add_argument("--out", default="dashboard.html")
        p_dashboard.set_defaults(func=cmd_dashboard)
    
        p_export = sub.add_parser("export")
        p_export.add_argument("--out", default="applications.csv")
        p_export.set_defaults(func=cmd_export)
    
        args = parser.parse_args()
        args.func(args)
    
    
    if __name__ == "__main__":
        main()
    
  • references/ats_platforms.md3.4 KBa3bc5c1b888bupstream ↗
    # Common ATS Platforms — Fingerprints & Field Notes
    
    Use this to identify which system is behind a company's application form
    before trying to automate it. Fingerprints are based on URL patterns and
    common DOM markers; always verify against the live page since companies
    customize heavily.
    
    ## Greenhouse
    - URL pattern: `boards.greenhouse.io/<company-slug>` or embedded widget on
      the company's own domain (`<company>.com/careers` loading a Greenhouse iframe).
    - Public API: `https://boards-api.greenhouse.io/v1/boards/<token>/jobs` returns
      open jobs as JSON — prefer this over scraping HTML when available.
    - Typical fields: first_name, last_name, email, phone, resume (file), cover
      letter (file, often optional), LinkedIn URL, custom questions (EEO,
      work authorization) defined per-company.
    
    ## Lever
    - URL pattern: `jobs.lever.co/<company-slug>/<posting-id>`
    - Typical fields: name, email, phone, resume (file), LinkedIn/portfolio URLs,
      a few custom questions. Application form is usually a single page.
    
    ## Workday
    - URL pattern: `<company>.wd1.myworkdayjobs.com` / `wd5` / etc (the number
      varies by Workday data center/tenant).
    - Multi-step wizard (My Information → My Experience → Application Questions →
      Voluntary Disclosures → Review). Often requires account creation first.
    - Heaviest to automate reliably — selectors are tenant-specific and the UI is
      React-driven with dynamic `data-automation-id` attributes. Budget extra
      time to record real selectors via a browser tool's inspector before
      attempting unattended fills.
    
    ## SmartRecruiters
    - URL pattern: `jobs.smartrecruiters.com/<company>/<posting-id>`
    - Typical fields: name, email, phone, resume upload, sometimes a short
      screening questionnaire.
    
    ## iCIMS
    - URL pattern: `<company>.icims.com` or `careers-<company>.icims.com`
    - Older, more varied markup; often multi-step with account creation.
    
    ## BambooHR (careers pages)
    - URL pattern: `<company>.bamboohr.com/jobs/`
    - Usually simple single-page forms: name, email, phone, resume upload.
    
    ## Workable
    - URL pattern: `apply.workable.com/<company>/j/<posting-id>`
    - Single-page form, generally straightforward to automate.
    
    ## 国内常见渠道
    - **智联招聘 / 前程无忧(51job) / 猎聘**:聚合平台,非公司官网;投递走平台内
      简历投递流程,通常需要平台账号登录。适合作为 Step 1 的候选来源,但按
      第 2 步的逻辑应优先寻找公司官网/自建招聘系统作为更精准的投递渠道。
    - **BOSS直聘**:以"聊天"为主要投递方式(与招聘人员在线沟通后发送简历),
      不是传统表单,不适合脚本化自动填表;建议引导用户手动完成对话式投递,
      或仅用它来发现在招岗位/联系人信息。
    - **企业自建招聘系统**(如大厂自有 `careers.<company>.com`):字段和流程
      因公司而异,需逐一查看后为其单独写 selector 映射,可仿照本文件的结构
      为常用目标公司积累一份 `references/company_specific/<company>.md`。
    
    ## General approach for an unrecognized ATS
    1. Open the form and inspect field `name`/`id`/`data-*` attributes.
    2. Identify: name field(s), email, phone, resume upload `input[type=file]`,
       cover letter upload (if separate), and the submit control.
    3. Add a new entry to `ATS_FIELD_MAP` in `scripts/ats_form_filler.py`.
    4. Test the fill (not the submit) first, and always let the human review the
       screenshot before authorizing `--confirm-submit`.
    
  • references/company_due_diligence.md4.7 KBee5abca24b77upstream ↗
    # Company Due Diligence (背调) — Sources, Query Templates & Interpretation
    
    Purpose: before (or right after) finding a company hiring for the target
    role, pull together publicly available signal on the company's financial
    health, legal risk, and employee sentiment — so the user can decide whether
    it's worth applying/continuing, not just chase any open posting.
    
    ## How to run this step
    This relies on `web_search` (or an equivalent search tool) in the calling
    agent's session, run live against each source below — NOT a local scraper.
    Most of these sites are JS-heavy, aggressively anti-bot, or login-walled, so
    scraping them from a script is unreliable and easy to get blocked on. Search
    queries against them (via a general search engine) surface the same public
    content far more robustly.
    
    For each candidate company, run a small batch of queries (don't skip
    categories — a company can look fine on one channel and be a red flag on
    another):
    
    ### 1. 工商 / 法律风险 (authoritative — check these first)
    - `<公司全称> 企查查`
    - `<公司全称> 天眼查 被执行人`
    - `<公司全称> 司法风险 失信被执行人`
    - `<公司全称> 劳动争议 裁判文书`
    - `<公司全称> 股权冻结`
    
    Prefer citing the **primary public registries** over secondary aggregators
    when a specific claim matters:
    - 国家企业信用信息公示系统 (gsxt.gov.cn) — official registration status,
      administrative penalties
    - 中国裁判文书网 (wenshu.court.gov.cn) — actual court judgments, including
      labor disputes (劳动争议) filed against the company
    - 中国执行信息公开网 (shixin.court.gov.cn) — 失信被执行人 (defaulting on
      court judgments) records
    企查查/天眼查 mostly re-package the same registry + judgment data with a
    nicer UI — fine as a starting point, but if a specific lawsuit or default
    matters to the user's decision, try to confirm against the primary source.
    
    ### 2. 员工口碑 / 工作体验
    - `<公司全称> 知乎 靠谱吗`
    - `<公司全称> 知乎 员工 评价`
    - `<公司全称> 看准网` or `<公司全称> Kanzhun review`(看准网/BOSS直聘企业版)
    - `<公司全称> 脉脉`
    - `<公司全称> 小红书 入职 感受`
    - `<公司全称> 小红书 吐槽`
    
    ### 3. 综合口碑 / 品牌
    - `<公司全称> 抖音 员工日常`(多为官方账号/营销内容,权重放低,主要看评论区真实反馈)
    - `<公司全称> 加班 猝死 舆情`(仅在有具体线索时补充搜索,不要预设结论)
    - `<公司全称> 融资历史`(用于判断财务健康度/现金流风险,尤其是早期创业公司)
    
    ## How to interpret and present findings
    
    - **Cite sources.** Every claim in the report should be attributable to a
      specific source (知乎回答/企查查记录/裁判文书号/小红书帖子), not stated as
      bare fact. Follow the same copyright-safe paraphrasing approach used
      elsewhere — summarize in your own words, don't reproduce long quotes.
    - **Weight primary/official records above social commentary.** A 裁判文书网
      labor-dispute judgment is a fact; a single 知乎 complaint is one person's
      account and may be biased, outdated, or exaggerated — note that distinction
      explicitly in the report rather than presenting both with equal confidence.
    - **Watch for astroturfing.** 抖音/小红书 company-branded content and posts
      that read like recruiting marketing aren't independent employee sentiment
      — flag this rather than counting it toward "positive reviews."
    - **Small sample ≠ trend.** One or two negative reviews out of a large
      company is normal noise; a consistent pattern across multiple independent
      sources (esp. combined with an actual court record) is the real signal.
    - **This is not legal or financial advice.** Present findings as information
      to weigh, not a verdict — the user makes the final call on whether to
      apply/accept an offer.
    
    ## Red-flag checklist (surface these prominently if found)
    - [ ] 失信被执行人 / 被强制执行 records
    - [ ] Multiple 劳动争议 (labor dispute) judgments, especially repeated ones
          over wages/overtime/unpaid social insurance
    - [ ] Frequent legal-entity or equity changes in a short period (可能预示
          资金链或控制权问题)
    - [ ] Recurring, specific employee complaints about unpaid wages, excessive
          unpaid overtime (996/007), or forced resignation practices — especially
          when corroborated across more than one independent source/platform
    - [ ] Recent large-scale layoffs or funding collapse reported in press/社媒
    
    ## Output format
    Feed structured findings into `scripts/due_diligence_report.py` to produce
    a shareable Markdown/HTML report per company (see that script's `--help`).
    Keep each section short — a due-diligence report is a decision aid, not an
    exhaustive dossier.
    
  • references/similar_projects.md3.5 KBa50fd640e3cbupstream ↗
    # Similar Open-Source Projects — What We Borrowed
    
    A quick survey of existing GitHub projects in this space, and which ideas
    made it into this skill (in our own words/implementation — no code copied).
    
    ## Auto_job_applier_linkedIn (GodsScion, ~2.8k stars)
    https://github.com/GodsScion/Auto_job_applier_linkedIn
    
    - **Pause-before-submit as a first-class setting** — confirms our own
      "never auto-submit without confirmation" rule is a common, expected
      pattern in this space, not an unusual restriction.
    - **`safe_mode` / `click_interval`** — randomized delay between actions to
      avoid looking like a bot and to avoid overwhelming a site. → adopted as
      the "batch in small groups (5–10) with review checkpoints" rule in
      SKILL.md; `ats_form_filler.py` should add explicit delays if you extend
      it to handle multiple applications in one run.
    - **Skip already-applied / blacklisted companies** — before filling a new
      application, check whether you've already got a record for that company.
      → adopted as the new `track_applications.py check --company` subcommand;
      wire it into Step 4 of the workflow before opening a new form.
    - **Local-only data, no cloud upload** — matches our tracker's design
      (plain JSON on disk, CSV/HTML export, nothing sent anywhere).
    - **A dedicated "Applied Jobs history" view in a local control panel** →
      adopted as `track_applications.py dashboard`, which generates a
      self-contained HTML page (summary cards + status bar chart + full table)
      instead of a running Flask app, to keep this skill dependency-light.
    
    ## simonfong6/auto-apply
    https://github.com/simonfong6/auto-apply
    
    - Confirms Greenhouse/Lever/Workday/Jobvite as the right set of major ATS
      platforms to target first — matches `references/ats_platforms.md`.
    
    ## Pickle-Pixel/ApplyPilot
    https://github.com/Pickle-Pixel/ApplyPilot
    
    - **Explicit "stages 1–5 only" mode**: discover → score-against-resume →
      tailor resume → write cover letter → fill form, with submission left as
      a manual last step. This is essentially the mode we default to; treat
      full autonomous submission as something only offered when the user
      explicitly asks for a batch to go all the way through, and even then
      always with the review checkpoint from Step 4 of SKILL.md.
    - **"Never fabricates" experience when tailoring a resume** — same
      constraint we already state under "Non-negotiable ground rules".
    
    ## Commercial "Job Application Tracker" spreadsheet templates (Gumroad/Etsy)
    Many independent listings converge on the same shape, which is a useful
    signal for what a tracker needs regardless of implementation:
    
    - Dashboard summary (totals, by status, by channel/source, by week)
    - Duplicate detection when logging a job you may have already tracked
    - Follow-up reminders based on days-since-last-update
    - A separate notes/company-research field
    
    All four are now in `track_applications.py` (`stats`, `add`'s duplicate
    warning, `followups`, and the `--notes` field respectively).
    
    ## What we deliberately did NOT borrow
    - Fully unattended multi-hundred-application "spray and pray" runs (some
      tools advertise "apply to 100+ jobs in under an hour"). This conflicts
      with our accuracy/quality and anti-spam principles — see SKILL.md's
      ground rules. Low-quality, unreviewed applications also just perform
      worse for the user.
    - CAPTCHA-solving services/bypass techniques that some auto-apply tools
      integrate. We stop and hand control back to a human instead — see the
      CAPTCHA handling in `ats_form_filler.py`.
    
  • .gitignore345 B553ab89df87aupstream ↗
    # Personal data generated by using this tool — never commit your own
    # job-search records.
    applications.json
    applications.csv
    dashboard.html
    *_report.html
    *_report.md
    *_findings.json
    
    # Python
    __pycache__/
    *.pyc
    *.pyo
    .venv/
    venv/
    
    # Playwright artifacts (screenshots taken while filling forms)
    filled_form.png
    
    # OS noise
    .DS_Store
    Thumbs.db
    
  • company_due_diligence.md6.3 KBa534d4b659b5upstream ↗
    # Company Due Diligence (背调) — Sources, Query Templates & Interpretation
    
    Purpose: before (or right after) finding a company hiring for the target
    role, pull together publicly available signal on the company's financial
    health, legal risk, and employee sentiment — so the user can decide whether
    it's worth applying/continuing, not just chase any open posting.
    
    ## How to run this step
    This relies on `web_search` (or an equivalent search tool) in the calling
    agent's session, run live against each source below — NOT a local scraper.
    Most of these sites are JS-heavy, aggressively anti-bot, or login-walled, so
    scraping them from a script is unreliable and easy to get blocked on. Search
    queries against them (via a general search engine) surface the same public
    content far more robustly.
    
    For each candidate company, run a small batch of queries (don't skip
    categories — a company can look fine on one channel and be a red flag on
    another):
    
    ### 1. 工商 / 法律风险 (authoritative — check these first)
    - `<公司全称> 企查查`
    - `<公司全称> 天眼查 被执行人`
    - `<公司全称> 司法风险 失信被执行人`
    - `<公司全称> 劳动争议 裁判文书`
    - `<公司全称> 股权冻结`
    
    Prefer citing the **primary public registries** over secondary aggregators
    when a specific claim matters:
    - 国家企业信用信息公示系统 (gsxt.gov.cn) — official registration status,
      administrative penalties
    - 中国裁判文书网 (wenshu.court.gov.cn) — actual court judgments, including
      labor disputes (劳动争议) filed against the company
    - 中国执行信息公开网 (shixin.court.gov.cn) — 失信被执行人 (defaulting on
      court judgments) records
    企查查/天眼查 mostly re-package the same registry + judgment data with a
    nicer UI — fine as a starting point, but if a specific lawsuit or default
    matters to the user's decision, try to confirm against the primary source.
    
    ### 2. 员工口碑 / 工作体验
    - `<公司全称> 知乎 靠谱吗`
    - `<公司全称> 知乎 员工 评价`
    - `<公司全称> 看准网` or `<公司全称> Kanzhun review`(看准网/BOSS直聘企业版)
    - `<公司全称> 脉脉`
    - `<公司全称> 小红书 入职 感受`
    - `<公司全称> 小红书 吐槽`
    
    ### 3. 综合口碑 / 品牌
    - `<公司全称> 抖音 员工日常`(多为官方账号/营销内容,权重放低,主要看评论区真实反馈)
    - `<公司全称> 加班 猝死 舆情`(仅在有具体线索时补充搜索,不要预设结论)
    - `<公司全称> 融资历史`(用于判断财务健康度/现金流风险,尤其是早期创业公司)
    
    ## How to interpret and present findings
    
    - **Cite sources.** Every claim in the report should be attributable to a
      specific source (知乎回答/企查查记录/裁判文书号/小红书帖子), not stated as
      bare fact. Follow the same copyright-safe paraphrasing approach used
      elsewhere — summarize in your own words, don't reproduce long quotes.
    - **Weight primary/official records above social commentary.** A 裁判文书网
      labor-dispute judgment is a fact; a single 知乎 complaint is one person's
      account and may be biased, outdated, or exaggerated — note that distinction
      explicitly in the report rather than presenting both with equal confidence.
    - **Watch for astroturfing.** 抖音/小红书 company-branded content and posts
      that read like recruiting marketing aren't independent employee sentiment
      — flag this rather than counting it toward "positive reviews."
    - **Small sample ≠ trend.** One or two negative reviews out of a large
      company is normal noise; a consistent pattern across multiple independent
      sources (esp. combined with an actual court record) is the real signal.
    - **This is not legal or financial advice.** Present findings as information
      to weigh, not a verdict — the user makes the final call on whether to
      apply/accept an offer.
    
    ## Red-flag checklist (surface these prominently if found)
    - [ ] 失信被执行人 / 被强制执行 records
    - [ ] Multiple 劳动争议 (labor dispute) judgments, especially repeated ones
          over wages/overtime/unpaid social insurance
    - [ ] Frequent legal-entity or equity changes in a short period (可能预示
          资金链或控制权问题)
    - [ ] Recurring, specific employee complaints about unpaid wages, excessive
          unpaid overtime (996/007), or forced resignation practices — especially
          when corroborated across more than one independent source/platform
    - [ ] Recent large-scale layoffs or funding collapse reported in press/社媒
    
    ## Known limitation: 小红书/抖音 coverage is incomplete by design
    
    This workflow uses a general search engine (`web_search`), never a logged-in
    scraper — see "How to run this step" above for why. The tradeoff: **general
    search engines index 小红书/抖音 content very poorly**, so a company can have
    real posts/comments on those platforms that a `web_search` pass simply won't
    surface, even with well-formed queries.
    
    - 小红书 in particular gates most content behind login, and even public posts
      are inconsistently crawled by external search engines — a note the user
      found by searching directly inside the 小红书 app may not turn up here.
    - 抖音 comments (where real sentiment usually lives, as opposed to the
      official account's video captions) are almost never indexed at all.
    
    **Do not treat an empty result from these two sources as "no findings" —
    treat it as "not covered by this method."** If the user has already found
    relevant posts themselves (by searching inside the app), the right move is
    to have them share the content or link directly, then fold it into the
    report's 社交媒体口碑 section attributed as **user-provided**, not
    Claude-sourced — same sourcing discipline as everything else in this file.
    
    Logging in as the user to search 小红书/抖音 directly is a possible
    technical fix but is deliberately out of scope here: it risks the user's
    account (aggressive anti-automation risk-control, possible bans) and would
    require building and maintaining login/cookie persistence and anti-scraping
    workarounds — a different, riskier kind of tool than the rest of this skill.
    
    ## Output format
    Feed structured findings into `scripts/due_diligence_report.py` to produce
    a shareable Markdown/HTML report per company (see that script's `--help`).
    Keep each section short — a due-diligence report is a decision aid, not an
    exhaustive dossier.
    
  • docs/company-report-screenshot.png224 KB95aa0e5bfe5cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/dashboard-screenshot.png94 KB17e8040a494aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/readme-hero.png2.2 MBb78d02a09fc2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • job-application-assistant.skill341 KBa1c3e6bf851cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • LICENSE1.0 KBa41878bf0982upstream ↗
    MIT License
    
    Copyright (c) 2026 LH-kevin
    
    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:
    
    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.
    
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.
    
  • README.en.md6.6 KB8d0519d73111upstream ↗
    # job-application-assistant
    
    **A personal job-search AI Skill for Claude / Codex**
    
    *[中文](README.md)*
    
    <p align="center">
      <img src="docs/readme-hero.png" alt="job-application-assistant — a personal AI Skill for job hunting" width="100%">
    </p>
    
    > **In one sentence:** let AI help you **find target companies → vet them before applying → carefully assist with application forms → track every application**, while every real submission still requires your confirmation.
    
    This is a **personal job-search** Skill for Claude / Codex, not a recruiting SaaS product.  
    There is no server, no account system, and no cloud sync. Your application data stays in a local JSON file on your machine.
    
    ---
    
    ## Understand it in 30 seconds
    
    ### 1. Install the Skill in Claude / Codex
    
    - **Claude (desktop / web):** go to `Settings → Capabilities → Skills`, then upload this project folder or a packaged `.skill` file.
    - **Claude Code / Codex:** place this project in the skills directory used by that tool.
    
    ### 2. Tell it what kind of role you want
    
    For example:
    
    ```text
    Help me find companies hiring for AI Agent development roles.
    Prefer each company's official careers page.
    Before I apply, run company due diligence.
    After I confirm, help me fill the application form
    and add the application to my tracker.
    ```
    
    ### 3. The Skill moves the process forward
    
    ```text
    Find openings
        ↓
    Choose target companies
        ↓
    Run company due diligence
        ↓
    Decide whether to continue
        ↓
    Assist with the application form
        ↓
    You confirm the real submission
        ↓
    Track the application + follow up
    ```
    
    **Less repetitive copying, less manual research, and less scattered tracking.**
    
    ---
    
    ## What it helps you do
    
    |  | Capability | What you get |
    |---|---|---|
    | 🔎 | **Find openings** | Search for companies hiring for a target role and prefer each company's **official careers page** |
    | 🏢 | **Vet before you apply** | Collect public signals on financial health, legal/judicial risk, employee sentiment, and social-media commentary |
    | 📝 | **Assist with ATS forms** | Help fill common ATS forms in a visible browser, including Greenhouse, Lever, and Workday |
    | 📊 | **Track applications** | Keep company, role, channel, status, risk label, and follow-up information in one place |
    | 🔁 | **Detect duplicates** | Check whether you have already applied to the same company |
    | 🔒 | **Keep data local** | No account, no server, no cloud sync; your application records stay on your machine |
    
    ---
    
    ## What the output looks like
    
    ### Application ledger
    
    See every application, current status, channel, last update, and due-diligence risk label at a glance.
    
    <p align="center">
      <img src="docs/dashboard-screenshot.png" alt="Application dashboard" width="100%">
    </p>
    
    ### Company due-diligence report
    
    Before deciding whether to keep applying or interviewing, consolidate legal/judicial risk, employee sentiment, and public social-media commentary into one report.
    
    <p align="center">
      <img src="docs/company-report-screenshot.png" alt="Company due-diligence report" width="78%">
    </p>
    
    Both pages are self-contained static HTML. No server is required, and the pages are regenerated from your own local data.
    
    ---
    
    ## Why this is not a one-click auto-apply tool
    
    The project deliberately keeps **human confirmation** in the loop.
    
    - **No automatic submission:** every real batch requires explicit confirmation.
    - **No CAPTCHA bypass:** the workflow stops and hands control back to you.
    - **No fabricated resume experience:** it does not invent facts to make you look more qualified.
    - **No fabricated due-diligence findings:** findings must be sourced.
    - **No unattended high-volume applying:** the workflow uses review checkpoints instead.
    
    The goal is not to maximize application volume. The goal is to make your job search **more informed, controllable, and easier to follow through**.
    
    ---
    
    ## Install
    
    The project is packaged as a **Claude Skill**:
    
    ```text
    SKILL.md
    scripts/
    references/
    ```
    
    ### Claude
    
    1. Open Claude.
    2. Go to `Settings → Capabilities → Skills`.
    3. Upload this project folder or a packaged `.skill` file.
    
    ### Claude Code / Codex
    
    Place the project into the skills directory documented by the tool you use.
    
    ---
    
    ## Python dependencies
    
    The tracking and report-generation scripts:
    
    - `scripts/track_applications.py`
    - `scripts/due_diligence_report.py`
    
    use only the Python standard library.
    
    The search and ATS form-assistance scripts require:
    
    ```bash
    pip install -r requirements.txt
    playwright install chromium
    ```
    
    Chromium is only needed if you use `ats_form_filler.py`.
    
    ---
    
    ## Quick CLI demo
    
    ```bash
    # Track an application
    python scripts/track_applications.py add \
      --company "Acme Corp" --role "Frontend Engineer" \
      --channel official_site --url "https://acme.com/careers/123" \
      --status submitted
    
    # Check whether you already applied
    python scripts/track_applications.py check --company "Acme Corp"
    
    # See applications that need follow-up
    python scripts/track_applications.py followups --days 7
    
    # Attach a due-diligence report
    python scripts/due_diligence_report.py --input acme_findings.json \
      --out acme_report.html --format html
    
    python scripts/track_applications.py diligence \
      --company "Acme Corp" --role "Frontend Engineer" \
      --risk medium --report acme_report.html --summary "1 labor dispute judgment"
    
    # Generate the dashboard
    python scripts/track_applications.py dashboard --out dashboard.html
    ```
    
    See each script's `--help` output and docstring for the full command reference.
    
    ---
    
    ## Workflow and design notes
    
    See [`SKILL.md`](SKILL.md) for the full step-by-step workflow.
    
    See [`references/`](references/) for the design notes behind each module, including which open-source auto-apply patterns were studied and which ones were deliberately not adopted.
    
    ---
    
    ## Data and privacy
    
    This is a **local-first personal job-search tool**:
    
    - no server
    - no account system
    - no cloud sync
    - application data stored in a local JSON file
    - real submissions require human confirmation
    
    ---
    
    ## Disclaimer
    
    This is a personal productivity tool, not legal, financial, or career advice.
    
    Due-diligence reports aggregate public information and social-media commentary. Verify any information that materially affects your decision—such as a specific lawsuit or company registration status—against a primary or authoritative source before acting.
    
    You are responsible for complying with the terms of service of any site this tool interacts with.
    
    ---
    
    ## License
    
    MIT — see [LICENSE](LICENSE).
    
    ---
    
    If this project improves your job-search workflow, consider giving it a **Star**, opening an **Issue**, or sharing your feedback.
    
  • requirements.txt298 B6a7d507f8edfupstream ↗
    # Core (used by search_target_companies.py / find_career_page.py)
    requests>=2.31
    beautifulsoup4>=4.12
    
    # Optional — only needed if you use scripts/ats_form_filler.py to fill
    # application forms with browser automation. After installing, also run:
    #   playwright install chromium
    playwright>=1.40
    

Plain-text copy, no login: /skill-bundles/lh-kevin-job-application-assistant.md

// REPO STATS

11 stars
0 open issues
Last commit: 2mo ago