') if page != 1: report.append("FAIL expected exactly one .page, found %d" % page) bad += 1 for marker in ("id=\"spn-shell-css\"", "class=\"spn-toggle\"", "id=\"spn-shell-js\""): c = note.count(marker) if c != 1: report.append("FAIL %s occurs %d times" % (marker, c)) bad += 1 # The skeleton's demo text and its Latin-only font stack both survive a build that reports # success, because each patch looks applied from the call site. if "Replace this title" in note: report.append("FAIL the demo title is still in the built note") bad += 1 if note.count("PingFang SC") != 2: report.append("FAIL the CJK font stack appears %d times, expected 2 (body and SVG)" % note.count("PingFang SC")) bad += 1 i, j = note.find('

'), note.find('') inner = note[i:j] heads = len(re.findall(r"]", inner)) if heads < 20: report.append("FAIL only %d h2/h3 headings inside .page" % heads) bad += 1 # Only the authored body is checked: the injected shell script legitimately contains `{{`. leftovers = sorted(set(re.findall(r"\{\{[A-Za-z0-9_]+\}\}", inner))) if leftovers: report.append("FAIL unresolved placeholders: %s" % ", ".join(leftovers[:8])) bad += 1 report.append("%s plumbing: 1 page column, 1 shell of each kind, %d headings, no placeholders" % ("PASS" if not bad else "FAIL", heads)) return bad def check_layout_static(note, report): """A browser-free substitute for the rendered-page assertions. The two hue assertions and the no-horizontal-scroll assertion normally run in a real browser against the finished file. A machine with no launchable browser cannot run them, so this group settles the two questions they answer, from the source instead: * every class the body uses is defined by the stylesheet that ships in the same file, so an element cannot silently fall back to unstyled black; * no unbreakable token is long enough to run a cell past the 880 px column, which is how a note overflows horizontally and the one breakage the eye misses. """ bad = 0 style = "".join(re.findall(r"]*>(.*?)", note, re.S)) defined = set(re.findall(r"\.([A-Za-z][\w-]*)", style)) i, j = note.find('

'), note.find("") body = note[i:j] used = set() for m in re.findall(r'class="([^"]+)"', body): used.update(m.split()) unknown = sorted(c for c in used if c not in defined) if unknown: report.append("FAIL classes used but not defined in the stylesheet: %s" % ", ".join(unknown)) bad += 1 else: report.append("PASS all %d classes used in the body are styled" % len(used)) # Longest unbreakable run in any text node, ignoring the code blocks (those scroll inside # their own

 by design).
    prose = re.sub(r"", " ", body, flags=re.S)
    text = html.unescape(re.sub(r"<[^>]+>", " ", prose))
    longest = ""
    for tok in text.split():
        if len(tok) > len(longest):
            longest = tok
    limit = 100                      # ~880 px at 8.8 px/char, the widest face in the sheet
    if len(longest) > limit:
        report.append("FAIL a %d-character unbreakable token risks a horizontal overflow: %r"
                      % (len(longest), longest[:60]))
        bad += 1
    else:
        report.append("PASS longest unbreakable token is %d characters (limit %d)"
                      % (len(longest), limit))

    nowrap = re.findall(r'(.*?)', body, re.S)
    fat = [c for c in nowrap if len(html.unescape(re.sub(r"<[^>]+>", "", c))) > 40]
    if fat:
        report.append("FAIL class=\"num\" (white-space:nowrap) on a cell holding a sentence: %r"
                      % fat[0][:60])
        bad += 1
    else:
        report.append("PASS %d nowrap cells, all short" % len(nowrap))
    return bad


CJK = re.compile(r"[\u2e80-\u9fff\uf900-\ufaff\uff00-\uffef\u3000-\u303f]")


def est_text_width(text, size):
    """Rough advance width in px: one em per CJK glyph, about 0.55 em per Latin one."""
    w = 0.0
    for ch in text:
        if CJK.match(ch):
            w += 1.0 * size
        elif ch == " ":
            w += 0.3 * size
        else:
            w += 0.55 * size
    return w


def check_figures_static(note, report):
    """A browser-free check of the one defect the stylesheet cannot show: a label that runs out
    of its viewBox.  The stylesheet does not theme SVG, so an overflowing label is invisible in
    the source and obvious on screen — approximate the advance width and flag the gross cases.
    """
    bad = 0
    figs = re.findall(r"]*viewBox=\"0 0 ([\d.]+) ([\d.]+)\"[^>]*>(.*?)", note, re.S)
    if not figs:
        report.append("FAIL no figure with a viewBox found")
        return 1
    for idx, (vw, vh, inner) in enumerate(figs):
        vw, vh = float(vw), float(vh)
        for attrs, text in re.findall(r"]*)>(.*?)", inner, re.S):
            label = html.unescape(re.sub(r"<[^>]+>", "", text)).strip()
            size = float((re.search(r'font-size="([\d.]+)"', attrs) or [None, 11])[1])
            x = float((re.search(r'\bx="(-?[\d.]+)"', attrs) or [None, 0])[1])
            y = float((re.search(r'\by="(-?[\d.]+)"', attrs) or [None, 0])[1])
            anchor = (re.search(r'text-anchor="(\w+)"', attrs) or [None, "start"])[1]
            w = est_text_width(label, size)
            left = x if anchor == "start" else (x - w / 2 if anchor == "middle" else x - w)
            right = left + w
            if right > vw + 1.0 or left < -1.0:
                report.append("FAIL figure %d: label %r spans %.0f–%.0f in a %.0f-wide viewBox"
                              % (idx + 1, label[:24], left, right, vw))
                bad += 1
            if y < 0 or y > vh:
                report.append("FAIL figure %d: label %r sits at y=%.0f, outside 0–%.0f"
                              % (idx + 1, label[:24], y, vh))
                bad += 1
    report.append("%s %d figure(s) checked for label overflow"
                  % ("PASS" if not bad else "FAIL", len(figs)))
    return bad


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--corpus", required=True)
    ap.add_argument("--note", default=os.path.join(HERE, os.pardir,
                                                   "agent-system-prompt-note.html"))
    args = ap.parse_args()

    note_path = os.path.abspath(args.note)
    if not os.path.exists(note_path):
        sys.stderr.write("no such note: %s\n" % note_path)
        return 2
    note = io.open(note_path, encoding="utf-8").read()

    report, bad = [], 0
    tmpdir = tempfile.mkdtemp(prefix="promptnote-")
    bad += check_quotes(note, args.corpus, report)
    bad += check_numbers(note, args.corpus, report, tmpdir)
    bad += check_plumbing(note, report)
    bad += check_layout_static(note, report)
    bad += check_figures_static(note, report)

    for line in report:
        sys.stdout.write(line + "\n")
    sys.stdout.write("\n%s  %d check group(s) failed  |  note: %s\n"
                     % ("FAILED" if bad else "OK", 0 if not bad else bad, note_path))
    return 1 if bad else 0


if __name__ == "__main__":
    sys.exit(main())