285 lines
12 KiB
Python
285 lines
12 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""Status-view gate — root STATUS.md stays one screen, and stays a VIEW of OPEN-ITEMS.md.
|
|
|
|
Run from the repo root: python3 scripts/status_view_gate.py [STATUS.md] [OPEN-ITEMS.md]
|
|
Exit 0 clean (or convicted before SWITCH_DATE: a loud WARNING) · 1 convicted · 2 inconclusive.
|
|
|
|
WHY THIS EXISTS. The operator's instruction for STATUS.md is: a plain-language view of
|
|
OPEN-ITEMS.md, never a second source of truth, one screen except the section that asks them to
|
|
decide. Nothing checked it, so every session prepended its news and nobody removed anything: on
|
|
2026-10-20 the page was 107 lines and about 31,700 characters, the „Updated" paragraph held three
|
|
weeks of news, eleven decided rows sat in the decide table, and the do list held finished items,
|
|
statements and Hungarian text. That page was rebuilt the same day; this gate keeps it rebuilt.
|
|
|
|
THE CHECKS (each has a decoy in scripts/test_status_view_gate.py that has been seen to fail):
|
|
size everything outside „Waiting on you — decide" is at most MAX_LINES lines and
|
|
MAX_CHARS characters (blank lines count: they take screen space too).
|
|
updated exactly one „**Updated" paragraph, at most MAX_UPDATED_SENTENCES sentences after its
|
|
bold lead, and no „Earlier" chain inside it (older news goes to STATUS-HISTORY.md).
|
|
english no Hungarian letter outside a quote („…", "…", “…”, `…`): a UI text or a page name
|
|
may be quoted, the page itself is English (STE).
|
|
open-ids every R-n the page cites is an OPEN row of OPEN-ITEMS.md.
|
|
decide no row of the decide table is decided, closed or done.
|
|
p1 every open P1 row appears under „What is broken" or „decide".
|
|
operator every open row whose Owner cell names the operator appears under „decide" or „do"
|
|
(a compact „Later:" line of ids counts).
|
|
|
|
WARN-FIRST until SWITCH_DATE (2026-10-27, register row R-1174, with a dated check in the
|
|
DUE-CHECKS block): before that date a conviction prints a WARNING and exits 0; from that date it
|
|
exits 1. INCONCLUSIVE (exit 2) has no warn period — a page with no sections or an unreadable
|
|
register is never a pass (the due-checks rule: a gate that finds nothing to check is not coverage).
|
|
|
|
A clean run says what it looked at (lines, characters, rows checked) — an absent complaint is not
|
|
evidence (workspace standing rule 3).
|
|
|
|
Stdlib only, no network, no subprocess: --fast, so it runs in the pre-push hook AND in CI.
|
|
"""
|
|
import os
|
|
import re
|
|
import sys
|
|
from datetime import date, datetime, timezone
|
|
|
|
for _stream in (sys.stdout, sys.stderr):
|
|
try:
|
|
_stream.reconfigure(encoding="utf-8", errors="replace")
|
|
except (AttributeError, ValueError, OSError): # pragma: no cover
|
|
pass
|
|
|
|
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
DEFAULT_STATUS = os.path.join(ROOT, "STATUS.md")
|
|
DEFAULT_REGISTER = os.path.join(ROOT, "documentation", "backlog", "OPEN-ITEMS.md")
|
|
|
|
# The one date the warning becomes a refusal. One constant, named in R-1174 and in the DUE-CHECKS block.
|
|
SWITCH_DATE = date(2026, 10, 27)
|
|
|
|
MAX_LINES = 50
|
|
MAX_CHARS = 6000
|
|
MAX_UPDATED_SENTENCES = 3
|
|
|
|
# Section headings, matched on the start of a `## ` line, case-insensitive.
|
|
SECTIONS = {
|
|
"works": "what works",
|
|
"broken": "what is broken",
|
|
"work_on": "what we work on",
|
|
"decide": "waiting on you — decide",
|
|
"do": "waiting on you — do",
|
|
}
|
|
|
|
HU_LETTERS = re.compile(u"[áéíóöőúüűÁÉÍÓÖŐÚÜŰ]")
|
|
# A quote is a span the page may carry in Hungarian: a UI text, a page name, a code span.
|
|
QUOTE_SPANS = [
|
|
re.compile(u"„[^\n„]*?[\"”]"),
|
|
re.compile(u"“[^\n“]*?”"),
|
|
re.compile(u"\"[^\"\n]*\""),
|
|
re.compile(u"`[^`\n]*`"),
|
|
]
|
|
RID = re.compile(r"\bR-(\d+)\b")
|
|
REG_ROW = re.compile(r"^\|\s*\*\*(R-\d+)\*\*\s*\|")
|
|
OPERATOR = re.compile(r"\b(operator|viktor)\b", re.I)
|
|
FINISHED = re.compile(r"\b(DECIDED|CLOSED)\b")
|
|
FINISHED_CELL = ("done", "decided", "closed")
|
|
SENTENCE_END = re.compile(u"[.!?](?=\\s+[A-Z„\"“(`*]|\\s*$)")
|
|
|
|
|
|
def inconclusive(msg, *more):
|
|
print("STATUS-VIEW GATE INCONCLUSIVE: " + msg)
|
|
for m in more:
|
|
print(" " + m)
|
|
print(" INCONCLUSIVE is not a pass: a gate that finds nothing to check is not coverage.")
|
|
sys.exit(2)
|
|
|
|
|
|
def today_utc():
|
|
override = os.environ.get("FELHOM_GATE_TODAY")
|
|
if override:
|
|
try:
|
|
d = datetime.strptime(override.strip(), "%Y-%m-%d").date()
|
|
except ValueError:
|
|
inconclusive("FELHOM_GATE_TODAY=%r is not YYYY-MM-DD" % override)
|
|
print("!! FELHOM_GATE_TODAY=%s IS SET — this gate is evaluating against that date, NOT "
|
|
"today's real UTC date. Unset it for a real run." % override.strip())
|
|
return d
|
|
return datetime.now(timezone.utc).date()
|
|
|
|
|
|
def read(path, what):
|
|
if not os.path.isfile(path):
|
|
inconclusive("%s not found at %s" % (what, path))
|
|
with open(path, encoding="utf-8-sig") as fh:
|
|
return fh.read()
|
|
|
|
|
|
def split_cells(line):
|
|
return [c.strip() for c in re.split(r"(?<!\\)\|", line.strip())[1:-1]]
|
|
|
|
|
|
def open_rows(text):
|
|
"""{id: (sev, owner)} for every register row. A literal `|` sits inside backticks (register rule)."""
|
|
rows = {}
|
|
for line in text.split("\n"):
|
|
m = REG_ROW.match(line)
|
|
if not m:
|
|
continue
|
|
# Split outside backticks, as register_shape_gate.py does.
|
|
cells, cur, tick = [], "", False
|
|
for ch in line.strip():
|
|
if ch == "`":
|
|
tick = not tick
|
|
if ch == "|" and not tick:
|
|
cells.append(cur)
|
|
cur = ""
|
|
else:
|
|
cur += ch
|
|
cells = [c.strip() for c in cells[1:]]
|
|
if len(cells) < 8:
|
|
continue
|
|
rows[m.group(1)] = (cells[2], cells[7])
|
|
return rows
|
|
|
|
|
|
def sections(lines):
|
|
"""{key: (start, end)} line ranges (heading line included), plus the list of all `## ` lines."""
|
|
heads = [i for i, l in enumerate(lines) if l.startswith("## ")]
|
|
found = {}
|
|
for n, i in enumerate(heads):
|
|
end = heads[n + 1] if n + 1 < len(heads) else len(lines)
|
|
title = lines[i][3:].strip().lower()
|
|
for key, want in SECTIONS.items():
|
|
if title.startswith(want) and key not in found:
|
|
found[key] = (i, end)
|
|
return heads, found
|
|
|
|
|
|
def unquote(s):
|
|
for rx in QUOTE_SPANS:
|
|
s = rx.sub(" ", s)
|
|
return s
|
|
|
|
|
|
def main(argv):
|
|
status_path = argv[1] if len(argv) > 1 else DEFAULT_STATUS
|
|
reg_path = argv[2] if len(argv) > 2 else DEFAULT_REGISTER
|
|
today = today_utc()
|
|
page = read(status_path, "STATUS page")
|
|
reg = open_rows(read(reg_path, "register"))
|
|
if not reg:
|
|
inconclusive("no register rows (`| **R-n** |`) in %s" % reg_path)
|
|
|
|
lines = page.rstrip("\n").split("\n")
|
|
heads, sec = sections(lines)
|
|
if not heads:
|
|
inconclusive("no `## ` sections in %s" % status_path)
|
|
missing = [SECTIONS[k] for k in SECTIONS if k not in sec]
|
|
if missing:
|
|
inconclusive("%s lacks the section(s): %s" % (status_path, ", ".join(missing)),
|
|
"The checks need every section; the page shape is in the repo CLAUDE.md.")
|
|
|
|
def text_of(*keys):
|
|
out = []
|
|
for k in keys:
|
|
a, b = sec[k]
|
|
out.extend(lines[a:b])
|
|
return "\n".join(out)
|
|
|
|
convictions = []
|
|
d0, d1 = sec["decide"]
|
|
outside = lines[:d0] + lines[d1:]
|
|
while outside and not outside[-1].strip():
|
|
outside.pop()
|
|
n_lines = len(outside)
|
|
n_chars = len("\n".join(outside))
|
|
|
|
# size
|
|
if n_lines > MAX_LINES:
|
|
convictions.append(("size", "%d lines outside „decide” (limit %d)" % (n_lines, MAX_LINES)))
|
|
if n_chars > MAX_CHARS:
|
|
convictions.append(("size", "%d characters outside „decide” (limit %d)" % (n_chars, MAX_CHARS)))
|
|
|
|
# updated
|
|
upd = [i for i, l in enumerate(lines) if "**Updated" in l]
|
|
if len(upd) != 1:
|
|
convictions.append(("updated", "%d „**Updated” paragraphs (exactly one is allowed)" % len(upd)))
|
|
else:
|
|
a = b = upd[0]
|
|
while a > 0 and lines[a - 1].strip():
|
|
a -= 1
|
|
while b + 1 < len(lines) and lines[b + 1].strip():
|
|
b += 1
|
|
para = " ".join(l.strip() for l in lines[a:b + 1])
|
|
body = re.sub(r"^.*?\*\*Updated[^*]*\*\*", "", para, count=1).strip()
|
|
n_sent = len(SENTENCE_END.findall(body))
|
|
if body and not SENTENCE_END.search(body[-1:] + " "):
|
|
n_sent += 1 # a last sentence without its full stop still counts
|
|
if n_sent > MAX_UPDATED_SENTENCES:
|
|
convictions.append(("updated", "the „Updated” paragraph has %d sentences (limit %d)"
|
|
% (n_sent, MAX_UPDATED_SENTENCES)))
|
|
if re.search(r"\bEarlier\b", para):
|
|
convictions.append(("updated", "the „Updated” paragraph carries an „Earlier” chain "
|
|
"(older news goes to STATUS-HISTORY.md)"))
|
|
|
|
# english
|
|
for no, l in enumerate(lines, 1):
|
|
bare = unquote(l)
|
|
m = HU_LETTERS.search(bare)
|
|
if m:
|
|
convictions.append(("english", "line %d: Hungarian outside a quote near %r"
|
|
% (no, bare[max(0, m.start() - 20):m.start() + 20].strip())))
|
|
|
|
# open-ids
|
|
cited = sorted(set("R-" + x for x in RID.findall(page)), key=lambda r: int(r[2:]))
|
|
for r in cited:
|
|
if r not in reg:
|
|
convictions.append(("open-ids", "%s is cited but is not an OPEN row" % r))
|
|
|
|
# decide
|
|
a, b = sec["decide"]
|
|
n_decide = 0
|
|
for no in range(a + 1, b):
|
|
l = lines[no].strip()
|
|
if not l.startswith("|") or re.match(r"^\|[\s:|-]+\|$", l) or re.match(r"^\|\s*#\s*\|", l):
|
|
continue
|
|
n_decide += 1
|
|
cells = [c.lower().strip("* ") for c in split_cells(l)]
|
|
if FINISHED.search(l) or any(c in FINISHED_CELL for c in cells):
|
|
convictions.append(("decide", "line %d: a decided/closed/done row in the decide table" % (no + 1)))
|
|
|
|
# p1
|
|
p1_text = text_of("broken", "decide")
|
|
p1_rows = sorted(r for r, (sev, _) in reg.items() if sev == "P1")
|
|
for r in p1_rows:
|
|
if not re.search(r"\b%s\b" % re.escape(r), p1_text):
|
|
convictions.append(("p1", "%s (P1) is not under „What is broken” or „decide”" % r))
|
|
|
|
# operator
|
|
op_text = text_of("decide", "do")
|
|
op_rows = sorted((r for r, (_, owner) in reg.items() if OPERATOR.search(owner)), key=lambda r: int(r[2:]))
|
|
for r in op_rows:
|
|
if not re.search(r"\b%s\b" % re.escape(r), op_text):
|
|
convictions.append(("operator", "%s names the operator as owner and is not under „decide” or „do”" % r))
|
|
|
|
print("status-view: %s" % status_path)
|
|
print("status-view: %d lines / %d characters outside „decide” (limits %d / %d); decide table %d row(s)"
|
|
% (n_lines, n_chars, MAX_LINES, MAX_CHARS, n_decide))
|
|
print("status-view: %d R-id(s) cited, checked against %d open register rows; %d P1 row(s); "
|
|
"%d operator-owned row(s)" % (len(cited), len(reg), len(p1_rows), len(op_rows)))
|
|
if not convictions:
|
|
print("status-view: OK — one screen, one „Updated” paragraph, English, every cited row open, "
|
|
"no finished decision, the P1 and every operator-owned row on the page")
|
|
return 0
|
|
refuse = today >= SWITCH_DATE
|
|
word = "CONVICTED" if refuse else "WARNING"
|
|
for check, msg in convictions:
|
|
print("status-view %s [%s]: %s" % (word, check, msg))
|
|
if refuse:
|
|
print("status-view: %d conviction(s) — refused (the warn-first period ended on %s, R-1174)"
|
|
% (len(convictions), SWITCH_DATE.isoformat()))
|
|
return 1
|
|
print("!! status-view: %d conviction(s) — WARNING ONLY until %s; from that date this gate REFUSES "
|
|
"the push (R-1174). Fix STATUS.md now." % (len(convictions), SWITCH_DATE.isoformat()))
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main(sys.argv))
|