Skip to content

dongshuyan/compass-skills / skills/assess-interview-candidate

assess-interview-candidate

Verified

根据候选人简历与岗位要求生成可审计的后台评估、简明的候选人介绍、按岗位重要性排列的简历疑点、12–18 道可直接照读的面试题,以及支持重点标记和本机保存的离线 HTML。用于招聘方准备结构化面试、核验岗位能力和记录回答。不要用于求职者模拟面试、私人背景调查、心理或人格诊断、从敏感属性推断表现,或自动录用、淘汰、排序候选人。

FileKindSize
SKILL.mdskill md17.9 KB
agents/openai.yamlconfig329 B
assets/candidate-assessment-template.htmlother35.5 KB
evals/evals.jsonconfig11.1 KB
references/agent-portability.mdmarkdown3.5 KB
references/evidence-and-inference-policy.mdmarkdown7.8 KB
references/job-modeling.mdmarkdown3.8 KB
references/privacy-and-fairness-cn.mdmarkdown7.1 KB
references/research-and-identity-policy.mdmarkdown4.0 KB
references/role-adapter-ai-llm-engineering.mdmarkdown5.7 KB
references/schema-evidence-ledger.jsonconfig6.2 KB
references/schema-interview-blueprint.jsonconfig5.6 KB
references/schema-interviewer-report.jsonconfig13.7 KB
references/schema-job-model.jsonconfig4.5 KB
references/schema-source-record.jsonconfig9.5 KB
references/scoring-and-coverage.mdmarkdown9.5 KB
references/structured-interview-methods.mdmarkdown4.8 KB
references/workflow-contract.mdmarkdown14.7 KB
scripts/calculate_interview_score.pyscript15.5 KB
scripts/create_candidate_case.pyscript3.6 KB
scripts/derive_timeline_age.pyscript9.9 KB
scripts/normalize_inputs.pyscript9.0 KB
scripts/prepare_candidate_photo.pyscript12.4 KB
scripts/render_candidate_report.pyscript5.3 KB
scripts/validate_candidate_report.pyscript10.1 KB
scripts/validate_case_contract.pyscript28.3 KB
scripts/validate_evidence_ledger.pyscript15.2 KB
scripts/validate_interviewer_report_data.pyscript35.4 KB
scripts/validate_source_log.pyscript21.4 KB
tests/test_candidate_profile_enrichment.pyscript40.3 KB
tests/test_interviewer_report.pyscript34.1 KB
tests/test_public_package.pyscript7.0 KB

scripts/validate_candidate_report.py

View on GitHub
#!/usr/bin/env python3
"""Validate the simplified offline interviewer report and interaction contract."""

from __future__ import annotations

import argparse
import json
import re
import sys
from html.parser import HTMLParser
from pathlib import Path
from typing import Any

from render_candidate_report import safe_filename_component
from validate_case_contract import loads_strict
from validate_interviewer_report_data import validate_interviewer_report_data


DATA_PLACEHOLDER = "__INTERVIEWER_REPORT_DATA_JSON__"
TITLE_PLACEHOLDER = "__REPORT_TITLE_HTML__"
REQUIRED_IDS = {
    "report-root",
    "report-title",
    "interviewer-report-data",
    "candidate-overview",
    "resume-risks",
    "interview-questions",
    "export-state",
    "reset-state",
    "storage-status",
}
V11_REQUIRED_IDS = {"candidate-photo"}
FORBIDDEN_OLD_IDS = {
    "assessment-root",
    "assessment-data",
    "resume-evidence-score",
    "interview-score",
    "core-interview-score",
    "coverage",
    "core-coverage",
    "gate-status",
    "comparability",
    "behavioral-hypotheses",
    "source-ledger",
}
REQUIRED_INTERACTION_MARKERS = {
    "localStorage",
    "loadState",
    "saveState",
    "applyDefaultHighlight",
    "exportInterviewState",
    "resetInterviewState",
}
NETWORK_JS = {
    "fetch()": re.compile(r"\bfetch\s*\(", re.I),
    "XMLHttpRequest": re.compile(r"\bXMLHttpRequest\b", re.I),
    "WebSocket": re.compile(r"\bWebSocket\s*\(", re.I),
    "EventSource": re.compile(r"\bEventSource\s*\(", re.I),
    "dynamic import": re.compile(r"\bimport\s*\(", re.I),
}


class ReportParser(HTMLParser):
    def __init__(self) -> None:
        super().__init__(convert_charrefs=True)
        self.ids: set[str] = set()
        self.non_embedded_dependencies: list[str] = []
        self.forbidden_data_uris: list[str] = []
        self.meta_refresh = False
        self.executable_scripts: list[str] = []
        self.report_data: list[str] = []
        self.report_data_script_count = 0
        self.styles: list[str] = []
        self.titles: list[str] = []
        self.h1_text: list[str] = []
        self.report_section_count = 0
        self._inside_executable_script = False
        self._inside_report_data = False
        self._inside_style = False
        self._inside_title = False
        self._inside_report_h1 = False

    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
        attributes = {key.lower(): (value or "") for key, value in attrs}
        if attributes.get("id"):
            self.ids.add(attributes["id"])
        tag = tag.lower()
        classes = set(attributes.get("class", "").split())
        if tag == "section" and "report-section" in classes:
            self.report_section_count += 1
        resource_attributes = {
            "script": "src",
            "link": "href",
            "img": "src",
            "source": "src",
            "audio": "src",
            "video": "src",
            "iframe": "src",
            "embed": "src",
            "object": "data",
        }
        attribute = resource_attributes.get(tag)
        if attribute:
            value = attributes.get(attribute, "").strip()
            if value.startswith("data:"):
                if tag != "img" or not re.match(r"^data:image/png;base64,", value, re.I):
                    self.forbidden_data_uris.append(f"<{tag} {attribute}={value[:80]!r}>")
            elif value:
                self.non_embedded_dependencies.append(f"<{tag} {attribute}={value!r}>")
        if tag == "meta" and attributes.get("http-equiv", "").lower() == "refresh":
            self.meta_refresh = True
        if tag == "script":
            script_type = attributes.get("type", "").strip().lower()
            self._inside_executable_script = script_type in {"", "text/javascript", "application/javascript", "module"}
            self._inside_report_data = script_type == "application/json" and attributes.get("id") == "interviewer-report-data"
            if self._inside_report_data:
                self.report_data_script_count += 1
        elif tag == "style":
            self._inside_style = True
        elif tag == "title":
            self._inside_title = True
        elif tag == "h1" and attributes.get("id") == "report-title":
            self._inside_report_h1 = True

    def handle_endtag(self, tag: str) -> None:
        if tag.lower() == "script":
            self._inside_executable_script = False
            self._inside_report_data = False
        elif tag.lower() == "style":
            self._inside_style = False
        elif tag.lower() == "title":
            self._inside_title = False
        elif tag.lower() == "h1":
            self._inside_report_h1 = False

    def handle_data(self, data: str) -> None:
        if self._inside_report_data:
            self.report_data.append(data)
        elif self._inside_executable_script:
            self.executable_scripts.append(data)
        elif self._inside_style:
            self.styles.append(data)
        elif self._inside_title:
            self.titles.append(data)
        elif self._inside_report_h1:
            self.h1_text.append(data)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Validate simplified report structure, embedded data, offline persistence, and highlighting controls.")
    parser.add_argument("report", type=Path, help="Rendered candidate interview HTML")
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    try:
        path = args.report.expanduser().resolve(strict=True)
        text = path.read_text(encoding="utf-8")
        parser = ReportParser()
        parser.feed(text)
        errors: list[str] = []
        warnings: list[str] = []
        if DATA_PLACEHOLDER in text or TITLE_PLACEHOLDER in text:
            errors.append("report template placeholder remains")
        missing_ids = sorted(REQUIRED_IDS - parser.ids)
        if missing_ids:
            errors.append(f"missing required element ids: {', '.join(missing_ids)}")
        forbidden_ids = sorted(FORBIDDEN_OLD_IDS & parser.ids)
        if forbidden_ids:
            errors.append(f"obsolete detailed-report element ids remain: {', '.join(forbidden_ids)}")
        if parser.report_section_count != 3:
            errors.append(f"report must contain exactly three main report sections; found {parser.report_section_count}")
        for marker in sorted(REQUIRED_INTERACTION_MARKERS):
            if marker not in text:
                errors.append(f"missing offline interaction marker: {marker}")
        if parser.non_embedded_dependencies:
            errors.append("non-embedded runtime dependencies found: " + "; ".join(parser.non_embedded_dependencies))
        if parser.forbidden_data_uris:
            errors.append("forbidden data URI resources found: " + "; ".join(parser.forbidden_data_uris))
        if parser.meta_refresh:
            errors.append("meta refresh is forbidden")
        if parser.report_data_script_count != 1:
            errors.append(f"report must contain exactly one interviewer-report-data JSON script; found {parser.report_data_script_count}")
        embedded = "".join(parser.report_data).strip()
        report_data: dict[str, Any] | None = None
        if parser.report_data_script_count == 1:
            try:
                value = loads_strict(embedded)
                if not isinstance(value, dict):
                    errors.append("embedded interviewer-report-data must be a JSON object")
                else:
                    report_data = value
                    contract_errors, contract_warnings = validate_interviewer_report_data(report_data)
                    errors.extend("embedded interviewer-report-data: " + item for item in contract_errors)
                    warnings.extend(contract_warnings)
            except (ValueError, json.JSONDecodeError) as exc:
                errors.append(f"embedded interviewer-report-data is not strict JSON: {exc}")
        if report_data is not None:
            if report_data.get("schema_version") == "1.1.0":
                missing_v11_ids = sorted(V11_REQUIRED_IDS - parser.ids)
                if missing_v11_ids:
                    errors.append(
                        "missing schema 1.1 element ids: " + ", ".join(missing_v11_ids)
                    )
            candidate_name = report_data["case"]["candidate_name"]
            expected_title = f"{candidate_name}|候选人评估与面试报告"
            title_text = "".join(parser.titles).strip()
            h1_text = "".join(parser.h1_text).strip()
            if title_text != expected_title:
                errors.append(f"document title must equal {expected_title!r}")
            if h1_text != expected_title:
                errors.append(f"page heading must equal {expected_title!r}")
            safe_name = safe_filename_component(candidate_name)
            if safe_name not in path.stem:
                errors.append(f"report filename must contain candidate name {safe_name!r}")
        executable_javascript = "\n".join(parser.executable_scripts)
        inline_css = "\n".join(parser.styles)
        if re.search(r"url\s*\(\s*['\"]?\s*(?!data:|#)[^)]+", inline_css, re.I):
            errors.append("non-embedded CSS url() dependency found")
        for label, pattern in NETWORK_JS.items():
            if pattern.search(executable_javascript):
                errors.append(f"network-capable JavaScript is forbidden in offline report: {label}")
        required_ids = set(REQUIRED_IDS)
        if report_data is not None and report_data.get("schema_version") == "1.1.0":
            required_ids.update(V11_REQUIRED_IDS)
        payload: dict[str, Any] = {
            "ok": not errors,
            "report": str(path),
            "bytes": path.stat().st_size,
            "required_ids": sorted(required_ids),
            "errors": errors,
            "warnings": warnings,
        }
        print(json.dumps(payload, ensure_ascii=False, indent=2))
        return 0 if not errors else 1
    except (OSError, UnicodeError) as exc:
        print(json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False), file=sys.stderr)
        return 2


if __name__ == "__main__":
    raise SystemExit(main())
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall