The career master and the pitfalls document are facts the user pastes or attaches per chat; every rule lives in the skills. build.sh zips each skill into claude-skills/dist/. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
626 lines
27 KiB
Python
626 lines
27 KiB
Python
#!/usr/bin/env python3
|
|
"""Deterministic style checks for application text: CV, cover letter, form answer, post.
|
|
|
|
Stdlib only, so it runs in any Python sandbox. Reads Markdown or plain text (a file
|
|
or stdin) and .docx. Prints Markdown tables: findings, counts per section and, for a
|
|
CV, bullets per role. Exit status 1 when an error-level finding exists, else 0.
|
|
|
|
Severity "error" means a rule is broken. Severity "check" is a heuristic hint
|
|
(spelling, Oxford comma, page estimate, layout) for a human or the model to confirm.
|
|
|
|
Usage:
|
|
python3 check_text.py draft.md
|
|
python3 check_text.py cv.docx --kind cv
|
|
python3 check_text.py answers.md --kind form --limit "Why us=1500" --word-limit "Motivation=200"
|
|
cat letter.txt | python3 check_text.py - --kind letter
|
|
"""
|
|
|
|
import argparse
|
|
import math
|
|
import re
|
|
import sys
|
|
import unicodedata
|
|
import zipfile
|
|
import xml.etree.ElementTree as ET
|
|
from dataclasses import dataclass, field
|
|
from pathlib import Path
|
|
|
|
HERE = Path(__file__).resolve().parent
|
|
|
|
EM_DASH = "\u2014"
|
|
NON_ASCII_DASHES = "\u2010\u2011\u2012\u2013\u2014\u2015\u2212"
|
|
YEAR = r"(?:19|20)\d{2}"
|
|
MONTH = r"(?:[A-Za-z\u00c0-\u017f]{3,9}\.?[^\S\n]+)?"
|
|
DATE_DASH = re.compile(
|
|
rf"{YEAR}[^\S\n]*[{NON_ASCII_DASHES}]"
|
|
rf"|[{NON_ASCII_DASHES}][^\S\n]*(?:{MONTH}{YEAR}|present\b|today\b|now\b|heute\b)",
|
|
re.IGNORECASE,
|
|
)
|
|
SPACED_EN_DASH = re.compile(r"(?<=\S)[^\S\n]+\u2013[^\S\n]+(?=\S)")
|
|
DOUBLE_HYPHEN = re.compile(r"(?<![-!<])--(?![->])")
|
|
SPACED_HYPHEN = re.compile(r"(?<=[A-Za-z\u00c0-\u017f,.)])[^\S\n]+-[^\S\n]+(?=[A-Za-z\u00c0-\u017f(])")
|
|
OXFORD = re.compile(
|
|
r"\b([\w+#.]+(?: [\w+#.]+)?), ([\w+#.]+(?: [\w+#.]+)?) (and|or) ([\w+#.]+)", re.UNICODE
|
|
)
|
|
EMAIL = re.compile(r"[\w.+-]+@[\w-]+(?:\.[\w-]+)+")
|
|
PHONE = re.compile(r"(?:\+|\b0)\d[\d ()/.-]{6,}\d")
|
|
MD_LINK = re.compile(r"\[([^\]]*)\]\(([^)]*)\)")
|
|
ICON_RANGES = (
|
|
(0x2600, 0x27BF), # miscellaneous symbols and dingbats: phone, envelope, check marks
|
|
(0x2B00, 0x2BFF), # arrows and symbols
|
|
(0xE000, 0xF8FF), # private use area: icon fonts
|
|
(0x1F000, 0x1FAFF), # emoji and pictographs
|
|
)
|
|
BULLET = re.compile(r"^(\s*)(?:[-*+\u2022\u00b7\u25aa\u25cf\u2023\u25e6]|\d{1,2}[.)])\s+(.*)$")
|
|
EXPERIENCE = re.compile(r"experience|erfahrung|work history|employment", re.I)
|
|
EARLIER = re.compile(r"earlier|previous|prior|other|additional|further|fr\u00fchere|weitere", re.I)
|
|
SALUTATION = re.compile(r"^(dear|hello|hi|sehr geehrte|liebe|lieber|hallo|guten tag)\b", re.I)
|
|
CLOSING = re.compile(
|
|
r"^(kind regards|best regards|warm regards|regards|yours sincerely|yours faithfully"
|
|
r"|sincerely|best wishes|mit freundlichen gr\u00fc\u00dfen|viele gr\u00fc\u00dfe"
|
|
r"|beste gr\u00fc\u00dfe|freundliche gr\u00fc\u00dfe)\b",
|
|
re.I,
|
|
)
|
|
|
|
# American spellings with their British form. Stems take the usual endings.
|
|
US_STEMS = (
|
|
"organiz", "optimiz", "prioritiz", "recogniz", "realiz", "specializ", "standardiz",
|
|
"minimiz", "maximiz", "summariz", "utiliz", "characteriz", "customiz", "digitiz",
|
|
"finaliz", "centraliz", "visualiz", "monetiz", "operationaliz", "productiz",
|
|
"containeriz", "virtualiz", "synchroniz", "authoriz", "categoriz", "emphasiz",
|
|
"normaliz", "parameteriz", "mobiliz", "stabiliz", "internationaliz", "localiz",
|
|
"modulariz", "industrializ", "capitaliz", "analyz", "paralyz",
|
|
)
|
|
US_STEM_RE = re.compile(
|
|
r"\b(" + "|".join(US_STEMS) + r")(e|es|ed|ing|ation|ations|er|ers)\b", re.I
|
|
)
|
|
US_WORDS = {
|
|
"color": "colour", "colors": "colours", "colored": "coloured", "colorful": "colourful",
|
|
"behavior": "behaviour", "behaviors": "behaviours", "behavioral": "behavioural",
|
|
"favor": "favour", "favorite": "favourite", "favorable": "favourable",
|
|
"honor": "honour", "honors": "honours", "labor": "labour", "neighbor": "neighbour",
|
|
"center": "centre", "centers": "centres", "centered": "centred",
|
|
"defense": "defence", "offense": "offence", "catalog": "catalogue", "dialog": "dialogue",
|
|
"modeling": "modelling", "modeled": "modelled", "labeled": "labelled",
|
|
"labeling": "labelling", "traveled": "travelled", "traveling": "travelling",
|
|
"canceled": "cancelled", "canceling": "cancelling", "fueled": "fuelled",
|
|
"enrollment": "enrolment", "fulfill": "fulfil", "fulfillment": "fulfilment",
|
|
"gray": "grey", "mold": "mould", "skillful": "skilful", "aging": "ageing",
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class Line:
|
|
no: int
|
|
raw: str
|
|
text: str # markup stripped
|
|
kind: str # heading, bullet, text, blank
|
|
level: int = 0
|
|
indent: int = 0
|
|
section: str = ""
|
|
|
|
|
|
@dataclass
|
|
class Block:
|
|
label: str
|
|
section: str
|
|
in_experience: bool
|
|
bullets: list = field(default_factory=list) # [line_no, text]
|
|
|
|
|
|
@dataclass
|
|
class Finding:
|
|
severity: str
|
|
where: str
|
|
problem: str
|
|
rule: str
|
|
fix: str
|
|
|
|
|
|
# ----------------------------------------------------------------------------- input
|
|
|
|
|
|
W = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
|
|
|
|
|
|
def _para_text(p):
|
|
parts = []
|
|
for el in p.iter():
|
|
if el.tag == W + "t":
|
|
parts.append(el.text or "")
|
|
elif el.tag == W + "tab":
|
|
parts.append("\t")
|
|
elif el.tag in (W + "br", W + "cr"):
|
|
parts.append(" ")
|
|
return "".join(parts)
|
|
|
|
|
|
def read_docx(path):
|
|
"""Return (markdown-ish text, layout findings) for a .docx file."""
|
|
findings = []
|
|
with zipfile.ZipFile(path) as z:
|
|
root = ET.fromstring(z.read("word/document.xml"))
|
|
header_text = " ".join(
|
|
_para_text(p)
|
|
for name in z.namelist()
|
|
if re.match(r"word/(header|footer)\d*\.xml$", name)
|
|
for p in ET.fromstring(z.read(name)).iter(W + "p")
|
|
)
|
|
body = root.find(W + "body")
|
|
out = []
|
|
for p in body.iter(W + "p"):
|
|
text = _para_text(p).strip()
|
|
if not text:
|
|
out.append("")
|
|
continue
|
|
ppr = p.find(W + "pPr")
|
|
style = ""
|
|
is_list = False
|
|
if ppr is not None:
|
|
ps = ppr.find(W + "pStyle")
|
|
style = ps.get(W + "val", "") if ps is not None else ""
|
|
is_list = ppr.find(W + "numPr") is not None
|
|
m = re.match(r"(?i)(?:heading|berschrift|titre|kop)\s*(\d)", style)
|
|
if m:
|
|
out.append("#" * int(m.group(1)) + " " + text)
|
|
elif style.lower() == "title":
|
|
out.append("# " + text)
|
|
elif is_list or "list" in style.lower():
|
|
out.append("- " + text)
|
|
else:
|
|
out.append(text)
|
|
if body.find(".//" + W + "tbl") is not None:
|
|
findings.append(Finding("check", "document", "table found", "Single column",
|
|
"use tables only for real tabular data; layout tables can scramble ATS reading order"))
|
|
if body.find(".//" + W + "txbxContent") is not None:
|
|
findings.append(Finding("check", "document", "text box found", "Single column",
|
|
"move text-box content into the body; many ATS skip text boxes"))
|
|
for cols in body.iter(W + "cols"):
|
|
if int(cols.get(W + "num", "1") or 1) > 1:
|
|
findings.append(Finding("check", "document", "multi-column section", "Single column",
|
|
"use a single column; columns interleave in extraction"))
|
|
break
|
|
text = "\n".join(out)
|
|
for kind, pattern in (("email", EMAIL), ("phone", PHONE)):
|
|
for m in pattern.finditer(header_text):
|
|
if m.group(0) not in text:
|
|
findings.append(Finding("error", "header/footer", f"{kind} {m.group(0)!r} only in the page header or footer",
|
|
"Plain-text contact", "put it in the body text; many ATS ignore headers and footers"))
|
|
return text, findings
|
|
|
|
|
|
def strip_markup(s):
|
|
s = MD_LINK.sub(r"\1", s)
|
|
s = re.sub(r"(\*\*|__|`)", "", s)
|
|
s = re.sub(r"(?<!\w)[*_](?=\S)(.+?)(?<=\S)[*_](?!\w)", r"\1", s)
|
|
return s
|
|
|
|
|
|
def is_caps_heading(s):
|
|
letters = [c for c in s if c.isalpha()]
|
|
return (
|
|
len(letters) >= 3
|
|
and len(s) <= 60
|
|
and all(not c.islower() for c in letters)
|
|
and len(s.split()) <= 6
|
|
and "," not in s
|
|
and not s.rstrip().endswith((".", ";", ":"))
|
|
and not EMAIL.search(s)
|
|
)
|
|
|
|
|
|
def parse(text):
|
|
lines = []
|
|
section = "(top)"
|
|
for i, raw in enumerate(text.splitlines(), 1):
|
|
stripped = raw.strip()
|
|
if not stripped:
|
|
lines.append(Line(i, raw, "", "blank", section=section))
|
|
continue
|
|
m = re.match(r"^(#{1,6})\s+(.*?)\s*#*$", stripped)
|
|
if m:
|
|
section = strip_markup(m.group(2))
|
|
lines.append(Line(i, raw, section, "heading", len(m.group(1)), section=section))
|
|
continue
|
|
b = BULLET.match(raw)
|
|
if b:
|
|
lines.append(Line(i, raw, strip_markup(b.group(2)), "bullet", indent=len(b.group(1)),
|
|
section=section))
|
|
continue
|
|
if is_caps_heading(stripped) and not re.search(r"\d{4}", stripped):
|
|
section = stripped.title() if stripped.isupper() else stripped
|
|
lines.append(Line(i, raw, section, "heading", 2, section=section))
|
|
continue
|
|
indent = len(raw) - len(raw.lstrip())
|
|
lines.append(Line(i, raw, strip_markup(stripped), "text", indent=indent, section=section))
|
|
return lines
|
|
|
|
|
|
# ---------------------------------------------------------------------------- checks
|
|
|
|
|
|
def excerpt(s, start, end, width=30):
|
|
a, b = max(0, start - width), min(len(s), end + width)
|
|
return ("..." if a else "") + s[a:b].strip() + ("..." if b < len(s) else "")
|
|
|
|
|
|
def load_banned(path):
|
|
phrases = []
|
|
for raw in path.read_text(encoding="utf-8").splitlines():
|
|
p = raw.strip()
|
|
if p and not p.startswith("#"):
|
|
phrases.append(p.lower())
|
|
phrases.sort(key=len, reverse=True)
|
|
compiled = []
|
|
for p in phrases:
|
|
parts = [re.escape(w) for w in p.split()]
|
|
body = r"\s+".join(parts).replace(r"\-", r"[-\s]?").replace("'", "['\u2019]")
|
|
compiled.append((p, re.compile(rf"(?<!\w){body}(?!\w)", re.I)))
|
|
return compiled
|
|
|
|
|
|
def where(line):
|
|
return f"L{line.no} ({line.section})"
|
|
|
|
|
|
def check_line(line, banned, findings):
|
|
s = line.text if line.kind != "heading" else line.raw.strip()
|
|
taken = []
|
|
for m in DATE_DASH.finditer(s):
|
|
dash = next(c for c in m.group(0) if c in NON_ASCII_DASHES)
|
|
taken.append((m.start(), m.end()))
|
|
findings.append(Finding("error", where(line), f"date range joined by U+{ord(dash):04X}: \"{excerpt(s, m.start(), m.end())}\"",
|
|
"ASCII date ranges", "use a single ASCII hyphen: 2016-2024"))
|
|
for i, c in enumerate(s):
|
|
if c == EM_DASH and not any(a <= i < b for a, b in taken):
|
|
findings.append(Finding("error", where(line), f"em dash: \"{excerpt(s, i, i + 1)}\"",
|
|
"No em dashes", "comma, full stop, colon or a new sentence"))
|
|
for m in SPACED_EN_DASH.finditer(s):
|
|
if not any(a <= m.start() < b or a < m.end() <= b for a, b in taken):
|
|
findings.append(Finding("error", where(line), f"spaced en dash used as a dash: \"{excerpt(s, m.start(), m.end())}\"",
|
|
"No em dashes", "comma, full stop, colon or a new sentence"))
|
|
if "://" not in s:
|
|
for m in DOUBLE_HYPHEN.finditer(s):
|
|
findings.append(Finding("error", where(line), f"'--' used as a dash: \"{excerpt(s, m.start(), m.end())}\"",
|
|
"No em dashes", "comma, full stop, colon or a new sentence"))
|
|
for m in SPACED_HYPHEN.finditer(s):
|
|
findings.append(Finding("check", where(line), f"spaced hyphen may stand in for a dash: \"{excerpt(s, m.start(), m.end())}\"",
|
|
"No em dashes", "comma, full stop, colon or a new sentence, unless it is a range"))
|
|
used = []
|
|
for _phrase, rx in banned:
|
|
for m in rx.finditer(s):
|
|
if any(a <= m.start() < b for a, b in used):
|
|
continue
|
|
used.append((m.start(), m.end()))
|
|
findings.append(Finding("error", where(line), f"banned phrase \"{m.group(0)}\"",
|
|
"Banned phrases", "replace with the evidence it stands in for"))
|
|
for m in US_STEM_RE.finditer(s):
|
|
word = m.group(0)
|
|
stem = m.group(1)
|
|
brit = stem[:-1] + ("s" if stem[-1] == "z" else "S") + m.group(2)
|
|
findings.append(Finding("check", where(line), f"American spelling \"{word}\"", "British spelling",
|
|
f"{brit} (unless it is a name)"))
|
|
for m in re.finditer(r"[A-Za-z]+", s):
|
|
brit = US_WORDS.get(m.group(0).lower())
|
|
if brit:
|
|
findings.append(Finding("check", where(line), f"American spelling \"{m.group(0)}\"", "British spelling",
|
|
f"{brit} (unless it is a name)"))
|
|
for m in OXFORD.finditer(s):
|
|
findings.append(Finding("check", where(line), f"list without Oxford comma? \"{m.group(0)}\"", "Oxford comma",
|
|
f"{m.group(1)}, {m.group(2)}, {m.group(3)} {m.group(4)}"))
|
|
for c in s:
|
|
cp = ord(c)
|
|
if any(a <= cp <= b for a, b in ICON_RANGES):
|
|
findings.append(Finding("error", where(line), f"icon glyph U+{cp:04X} \"{c}\"", "No icon glyphs",
|
|
"plain words: Phone, Email, or nothing"))
|
|
for m in MD_LINK.finditer(line.raw):
|
|
label, target = m.group(1), m.group(2)
|
|
if target.startswith(("mailto:", "tel:")) and target.split(":", 1)[1].strip() not in label:
|
|
findings.append(Finding("error", where(line), f"contact only in a link target: [{label}]({target})",
|
|
"Plain-text contact", "print the address or number as the visible text"))
|
|
|
|
|
|
def block_label(section, label_line):
|
|
if label_line is None:
|
|
return section
|
|
t = label_line.text
|
|
return f"{section} > {t[:50]}{'...' if len(t) > 50 else ''}"
|
|
|
|
|
|
def collect_blocks(lines):
|
|
blocks = []
|
|
cur = None
|
|
label_line = None
|
|
last_bullet = None
|
|
exp_level = None # heading level of the open experience subtree
|
|
in_exp = False
|
|
for ln in lines:
|
|
if ln.kind == "heading":
|
|
cur, label_line, last_bullet = None, None, None
|
|
if exp_level is not None and ln.level <= exp_level:
|
|
exp_level, in_exp = None, False
|
|
if EXPERIENCE.search(ln.text) and not EARLIER.search(ln.text):
|
|
exp_level, in_exp = ln.level, True
|
|
continue
|
|
if ln.kind == "bullet":
|
|
if cur is None:
|
|
cur = Block(block_label(ln.section, label_line), ln.section, in_exp)
|
|
blocks.append(cur)
|
|
cur.bullets.append([ln.no, ln.text])
|
|
last_bullet = ln
|
|
continue
|
|
if ln.kind == "text":
|
|
if cur is not None and last_bullet is not None and ln.indent > last_bullet.indent \
|
|
and ln.no == last_bullet.no + 1:
|
|
cur.bullets[-1][1] += " " + ln.text
|
|
last_bullet = ln
|
|
continue
|
|
if cur is not None:
|
|
cur, label_line = None, None
|
|
if label_line is None:
|
|
label_line = ln
|
|
return blocks
|
|
|
|
|
|
def experience_lines(lines, line_chars):
|
|
"""Estimated rendered lines per experience subtree (heading, est. lines)."""
|
|
out = []
|
|
i = 0
|
|
while i < len(lines):
|
|
ln = lines[i]
|
|
if ln.kind == "heading" and EXPERIENCE.search(ln.text) and not EARLIER.search(ln.text):
|
|
total = 1
|
|
j = i + 1
|
|
while j < len(lines) and not (lines[j].kind == "heading" and lines[j].level <= ln.level):
|
|
total += rendered_lines(lines[j], line_chars)
|
|
j += 1
|
|
out.append((ln, total))
|
|
i = j
|
|
else:
|
|
i += 1
|
|
return out
|
|
|
|
|
|
def rendered_lines(ln, line_chars):
|
|
if ln.kind == "blank":
|
|
return 0
|
|
width = line_chars - 4 if ln.kind == "bullet" else line_chars
|
|
return max(1, math.ceil(len(ln.text) / width))
|
|
|
|
|
|
def detect_kind(lines):
|
|
if any(ln.kind == "heading" and EXPERIENCE.search(ln.text) for ln in lines):
|
|
return "cv"
|
|
if any(ln.kind == "text" and SALUTATION.match(ln.text) for ln in lines):
|
|
return "letter"
|
|
return "text"
|
|
|
|
|
|
def letter_body(lines):
|
|
start = next((i for i, ln in enumerate(lines) if ln.kind == "text" and SALUTATION.match(ln.text)), None)
|
|
if start is None:
|
|
return [ln for ln in lines if ln.kind in ("text", "bullet")], None
|
|
end = next((i for i in range(start + 1, len(lines)) if lines[i].kind == "text" and CLOSING.match(lines[i].text)),
|
|
len(lines))
|
|
body = [ln for ln in lines[start + 1:end] if ln.kind in ("text", "bullet")]
|
|
return body, (lines[start].no + 1, lines[end - 1].no)
|
|
|
|
|
|
def words(s):
|
|
return len(re.findall(r"[\w\u00c0-\u017f'\u2019+#.-]+", s))
|
|
|
|
|
|
def section_stats(lines, line_chars):
|
|
stats = {}
|
|
order = []
|
|
for ln in lines:
|
|
if ln.kind == "heading":
|
|
if ln.section not in stats:
|
|
order.append(ln.section)
|
|
stats[ln.section] = []
|
|
continue
|
|
if ln.section not in stats:
|
|
order.append(ln.section)
|
|
stats[ln.section] = []
|
|
stats[ln.section].append(ln)
|
|
rows = []
|
|
for name in order:
|
|
body = stats[name]
|
|
while body and body[0].kind == "blank":
|
|
body = body[1:]
|
|
while body and body[-1].kind == "blank":
|
|
body = body[:-1]
|
|
text = "\n".join(ln.text for ln in body)
|
|
rows.append({
|
|
"section": name,
|
|
"chars": len(text),
|
|
"chars_ns": len(re.sub(r"\s", "", text)),
|
|
"words": words(text),
|
|
"lines": sum(rendered_lines(ln, line_chars) for ln in body),
|
|
})
|
|
return rows
|
|
|
|
|
|
def parse_limits(items, flag):
|
|
out = {}
|
|
for item in items or []:
|
|
name, sep, n = item.rpartition("=")
|
|
if not sep or not n.strip().isdigit():
|
|
sys.exit(f"{flag} expects NAME=NUMBER, got {item!r}")
|
|
out[name.strip().lower()] = int(n)
|
|
return out
|
|
|
|
|
|
def line_key(f):
|
|
m = re.match(r"(?:body )?L(\d+)", f.where)
|
|
return int(m.group(1)) if m else 0
|
|
|
|
|
|
def cell(s):
|
|
return str(s).replace("|", "\\|").replace("\n", " ")
|
|
|
|
|
|
def run(text, args, pre_findings=()):
|
|
text = unicodedata.normalize("NFC", text)
|
|
lines = parse(text)
|
|
kind = args.kind if args.kind != "auto" else detect_kind(lines)
|
|
banned = load_banned(Path(args.banned))
|
|
findings = list(pre_findings)
|
|
for ln in lines:
|
|
if ln.kind != "blank":
|
|
check_line(ln, banned, findings)
|
|
|
|
blocks = collect_blocks(lines) if kind == "cv" else []
|
|
if kind == "cv":
|
|
if not EMAIL.search(text):
|
|
findings.append(Finding("check", "document", "no email address found as plain text", "Plain-text contact",
|
|
"print the email in the body"))
|
|
if not PHONE.search(text):
|
|
findings.append(Finding("check", "document", "no phone number found as plain text", "Plain-text contact",
|
|
"print the phone number in the body, if the CV should carry one"))
|
|
role_blocks = [b for b in blocks if b.in_experience] or blocks
|
|
prev = None
|
|
for b in role_blocks:
|
|
n = len(b.bullets)
|
|
if n > args.max_bullets:
|
|
findings.append(Finding("error", f"L{b.bullets[0][0]} ({b.label})", f"{n} bullets",
|
|
f"At most {args.max_bullets} bullets per role", "cut by relevance to the posting"))
|
|
same_list = prev is not None and (prev.section == b.section or (prev.in_experience and b.in_experience))
|
|
if same_list and n > len(prev.bullets):
|
|
findings.append(Finding("check", f"L{b.bullets[0][0]} ({b.label})",
|
|
f"{n} bullets, more than the role above it ({len(prev.bullets)})",
|
|
"Fewer bullets for older roles", "if this role is older, cut it down"))
|
|
prev = b
|
|
limit = 2 * args.line_chars
|
|
for b in blocks:
|
|
for no, t in b.bullets:
|
|
if len(t) > limit:
|
|
est = math.ceil(len(t) / (args.line_chars - 4))
|
|
findings.append(Finding("error", f"L{no} ({b.label})",
|
|
f"bullet of {len(t)} chars, about {est} lines at {args.line_chars} chars per line",
|
|
"Bullets at most 2 lines", "split or cut"))
|
|
for heading, est in experience_lines(lines, args.line_chars):
|
|
if est > args.page_lines:
|
|
findings.append(Finding("check", f"L{heading.no} ({heading.text})",
|
|
f"about {est} rendered lines; one page holds about {args.page_lines}",
|
|
"Experience at most one page", "move older roles to an earlier-experience section on page two"))
|
|
|
|
body_info = None
|
|
if kind == "letter" or args.words:
|
|
body, span = letter_body(lines)
|
|
n = words("\n".join(ln.text for ln in body))
|
|
lo, hi = (250, 300)
|
|
if args.words:
|
|
lo_s, _, hi_s = args.words.partition("-")
|
|
lo, hi = int(lo_s), int(hi_s or lo_s)
|
|
body_info = (n, span, lo, hi)
|
|
if not lo <= n <= hi:
|
|
findings.append(Finding("error", f"body L{span[0]}-L{span[1]}" if span else "whole text",
|
|
f"{n} body words", f"Letter {lo}-{hi} words",
|
|
"cut restating sentences first" if n > hi else "add one forward-looking task"))
|
|
|
|
rows = section_stats(lines, args.line_chars)
|
|
char_limits = parse_limits(args.limit, "--limit")
|
|
word_limits = parse_limits(args.word_limit, "--word-limit")
|
|
by_name = {r["section"].lower(): r for r in rows}
|
|
for name, n in char_limits.items():
|
|
r = by_name.get(name)
|
|
if r is None:
|
|
findings.append(Finding("error", name, "section not found for --limit", "Character limit", "check the heading text"))
|
|
elif r["chars"] > n:
|
|
findings.append(Finding("error", r["section"], f"{r['chars']} chars, limit {n}", "Character limit",
|
|
f"cut {r['chars'] - n} characters"))
|
|
for name, n in word_limits.items():
|
|
r = by_name.get(name)
|
|
if r is None:
|
|
findings.append(Finding("error", name, "section not found for --word-limit", "Word limit", "check the heading text"))
|
|
elif r["words"] > n:
|
|
findings.append(Finding("error", r["section"], f"{r['words']} words, limit {n}", "Word limit",
|
|
f"cut {r['words'] - n} words"))
|
|
if args.max_chars is not None and len(text.strip()) > args.max_chars:
|
|
findings.append(Finding("error", "whole text", f"{len(text.strip())} chars, limit {args.max_chars}",
|
|
"Character limit", f"cut {len(text.strip()) - args.max_chars} characters"))
|
|
|
|
findings.sort(key=line_key)
|
|
out = []
|
|
out.append(f"## check_text: {args.source} (kind: {kind})\n")
|
|
out.append("### Findings\n")
|
|
if findings:
|
|
out.append("| # | Severity | Where | Problem | Rule | Suggested fix |")
|
|
out.append("|---|---|---|---|---|---|")
|
|
for i, f in enumerate(findings, 1):
|
|
out.append(f"| {i} | {f.severity} | {cell(f.where)} | {cell(f.problem)} | {cell(f.rule)} | {cell(f.fix)} |")
|
|
else:
|
|
out.append("No findings.")
|
|
out.append("\n### Sections\n")
|
|
out.append("| Section | Chars | Chars without spaces | Words | Est. lines | Limit |")
|
|
out.append("|---|---|---|---|---|---|")
|
|
for r in rows:
|
|
lim = []
|
|
if r["section"].lower() in char_limits:
|
|
lim.append(f"{char_limits[r['section'].lower()]} chars")
|
|
if r["section"].lower() in word_limits:
|
|
lim.append(f"{word_limits[r['section'].lower()]} words")
|
|
out.append(f"| {cell(r['section'])} | {r['chars']} | {r['chars_ns']} | {r['words']} | {r['lines']} | {', '.join(lim)} |")
|
|
total = text.strip()
|
|
total_ns = len(re.sub(r"\s", "", total))
|
|
out.append(f"| (whole text) | {len(total)} | {total_ns} | {words(total)} | | |")
|
|
if body_info:
|
|
n, span, lo, hi = body_info
|
|
where_s = f"L{span[0]}-L{span[1]}" if span else "whole text"
|
|
out.append(f"\nLetter body ({where_s}): {n} words, target {lo}-{hi}.")
|
|
if blocks:
|
|
out.append("\n### Bullets per role\n")
|
|
out.append("| Role | Line | Bullets | Longest bullet (chars) | Est. lines |")
|
|
out.append("|---|---|---|---|---|")
|
|
for b in blocks:
|
|
longest = max(len(t) for _, t in b.bullets)
|
|
out.append(f"| {cell(b.label)} | L{b.bullets[0][0]} | {len(b.bullets)} | {longest} | "
|
|
f"{math.ceil(longest / (args.line_chars - 4))} |")
|
|
errors = sum(f.severity == "error" for f in findings)
|
|
checks = len(findings) - errors
|
|
out.append(f"\nSummary: {errors} error(s), {checks} check(s). Counts strip Markdown markup and bullet markers; "
|
|
f"a newline counts as one character. Line estimates assume {args.line_chars} characters per line.")
|
|
return "\n".join(out), errors
|
|
|
|
|
|
def build_parser():
|
|
p = argparse.ArgumentParser(description="Deterministic style checks for application text.")
|
|
p.add_argument("path", help="draft file (.md, .txt, .docx) or - for stdin")
|
|
p.add_argument("--kind", choices=("auto", "cv", "letter", "form", "post", "text"), default="auto")
|
|
p.add_argument("--banned", default=str(HERE / "banned_phrases.txt"), help="banned phrase list")
|
|
p.add_argument("--max-bullets", type=int, default=5, help="bullets per role (default 5)")
|
|
p.add_argument("--line-chars", type=int, default=90,
|
|
help="characters per rendered line, for bullet and page estimates (default 90, A4 at 10-11pt)")
|
|
p.add_argument("--page-lines", type=int, default=46, help="rendered lines per page (default 46)")
|
|
p.add_argument("--words", help="body word range for a letter, e.g. 250-300 (default for --kind letter)")
|
|
p.add_argument("--limit", action="append", help="NAME=CHARS for a section heading; repeatable")
|
|
p.add_argument("--word-limit", action="append", help="NAME=WORDS for a section heading; repeatable")
|
|
p.add_argument("--max-chars", type=int, help="character limit for the whole text")
|
|
return p
|
|
|
|
|
|
def main(argv=None):
|
|
for stream in (sys.stdout, sys.stderr):
|
|
if hasattr(stream, "reconfigure"):
|
|
stream.reconfigure(encoding="utf-8")
|
|
args = build_parser().parse_args(argv)
|
|
pre = []
|
|
if args.path == "-":
|
|
args.source = "stdin"
|
|
text = sys.stdin.read()
|
|
else:
|
|
path = Path(args.path)
|
|
args.source = path.name
|
|
if path.suffix.lower() == ".docx":
|
|
text, pre = read_docx(path)
|
|
else:
|
|
text = path.read_text(encoding="utf-8")
|
|
report, errors = run(text, args, pre)
|
|
print(report)
|
|
return 1 if errors else 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|