| |
| """The end-of-wave checklist as ONE command (analyze-paper, Close the loop). |
| |
| The checklist is mechanical, so it lives here rather than as prose an agent has |
| to replay in the right order. One run: |
| |
| 1. regenerates every derived file (GENERATORS, in order); |
| 2. runs every health check, scoped to the wave where the check supports it; |
| 3. prints the wave metrics (edge mix, against-share vs the vault's) and a |
| random sample of the wave's stance edges for the extraction spot-audit. |
| |
| It decides nothing: the report ends with the judgment calls left to the session |
| (integrity errors, dupe/chronology adjudication, retro-edge reading list, |
| spot-audit). After acting on them, rerun with --generate so the derived files |
| match the final notes, then commit. |
| |
| python3 _scripts/end_of_wave.py # wave = new notes vs git HEAD |
| python3 _scripts/end_of_wave.py --papers a,b --ideas x # explicit wave |
| python3 _scripts/end_of_wave.py --generate # step 1 only |
| python3 _scripts/end_of_wave.py --strict # exit 1 on integrity ERRORs |
| |
| The default wave is read from git: notes under papers/ influences/ ideas/ that |
| are untracked or added since HEAD (i.e. the uncommitted wave). |
| """ |
| import os |
| import random |
| import re |
| import subprocess |
| import sys |
| from collections import Counter |
|
|
| VAULT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| S = os.path.join(VAULT, "_scripts") |
| GENERATORS = ["make_ideas_index", "make_methods_index", "make_bib", "make_authors", |
| "make_toread", "make_similarity", "make_families", "make_status"] |
| STANCE_RE = re.compile(r"^(first-mention|argues-for|argues-against|nuances|tests)::\s*(.*)$", re.M) |
| SAMPLE = 10 |
|
|
|
|
| def run(script, *args): |
| r = subprocess.run([sys.executable, os.path.join(S, script + ".py"), *args], |
| cwd=VAULT, capture_output=True, text=True) |
| return r.returncode, (r.stdout + r.stderr).rstrip() |
|
|
|
|
| def wave_from_git(): |
| out = subprocess.run(["git", "status", "--porcelain", "--untracked-files=all", |
| "papers", "influences", "ideas"], |
| cwd=VAULT, capture_output=True, text=True).stdout |
| papers, ideas = [], [] |
| for ln in out.splitlines(): |
| code, path = ln[:2], ln[3:].strip().strip('"') |
| if not path.endswith(".md") or not ("?" in code or "A" in code): |
| continue |
| slug = os.path.basename(path)[:-3] |
| (ideas if path.startswith("ideas/") else papers).append(slug) |
| return sorted(papers), sorted(ideas) |
|
|
|
|
| def opt(args, name): |
| if name in args: |
| return [s.strip() for s in args[args.index(name) + 1].split(",") if s.strip()] |
| return None |
|
|
|
|
| def section(title): |
| print(f"\n{'=' * 8} {title} {'=' * max(0, 60 - len(title))}") |
|
|
|
|
| def edges_of(slug): |
| for d in ("papers", "influences"): |
| p = os.path.join(VAULT, d, slug + ".md") |
| if os.path.exists(p): |
| return STANCE_RE.findall(open(p, encoding="utf-8").read()) |
| return [] |
|
|
|
|
| def main(): |
| args = sys.argv[1:] |
| section("1. regenerate derived files") |
| for g in GENERATORS: |
| code, out = run(g) |
| last = out.splitlines()[-1] if out else "" |
| print(f" {'OK ' if code == 0 else 'ERR'} {g}: {last[:110]}") |
| if code: |
| print(out) |
| if "--generate" in args: |
| return 0 |
|
|
| papers, ideas = wave_from_git() |
| papers = opt(args, "--papers") or papers |
| ideas = opt(args, "--ideas") or ideas |
| print(f"\n wave: {len(papers)} papers {papers}\n {len(ideas)} new ideas {ideas}") |
|
|
| section("2a. integrity (whole vault)") |
| code, out = run("check_integrity") |
| errs = 0 |
| for ln in out.splitlines(): |
| if ln.startswith("===") or ln.startswith("summary") or \ |
| any(f"] {p}" in ln or f"[[{p}]]" in ln or f" {p}:" in ln for p in papers + ideas): |
| print(ln) |
| m = re.match(r"summary: (\d+) errors", ln) |
| errs = int(m.group(1)) if m else errs |
| print(" (warnings above are filtered to the wave; run check_integrity.py for all)") |
|
|
| section("2b. slug dupes / year drift") |
| _, out = run("check_slug_dupes") |
| keep = [ln for ln in out.splitlines() if "CANDIDATE" not in ln and "same-author" not in ln] |
| print("\n".join(keep)) |
|
|
| if ideas: |
| section("2c. idea near-duplicates (new ideas only)") |
| print(run("check_idea_dupes", "--new", ",".join(ideas))[1]) |
| section("2d. retro-edge reading list (new ideas)") |
| print(run("suggest_retro_edges", "--new", ",".join(ideas))[1]) |
| if papers: |
| section("2e. first-mention chronology (wave papers)") |
| print(run("check_chronology", *papers)[1]) |
|
|
| section("3. wave metrics") |
| wave = Counter(k for p in papers for k, _ in edges_of(p)) |
| vault = Counter() |
| for d in ("papers", "influences"): |
| for f in os.listdir(os.path.join(VAULT, d)): |
| if f.endswith(".md"): |
| vault.update(k for k, _ in edges_of(f[:-3])) |
|
|
| def share(c): |
| votes = c["argues-for"] + c["first-mention"] + c["argues-against"] |
| return f"{100 * c['argues-against'] / votes:.1f}%" if votes else "n/a" |
| print(" edge mix (wave): " + ", ".join(f"{k} {v}" for k, v in wave.most_common())) |
| print(f" against-share of stance votes: wave {share(wave)} | vault {share(vault)}" |
| " (low = the related-work disagreement pass may be thin)") |
|
|
| section(f"4. spot-audit sample ({SAMPLE} stance edges; verify vs pdf/<slug>.txt)") |
| pool = [(p, k, v) for p in papers for k, v in edges_of(p)] |
| random.seed(" ".join(papers)) |
| for p, k, v in random.sample(pool, min(SAMPLE, len(pool))): |
| txt = "txt" if os.path.exists(os.path.join(VAULT, "pdf", p + ".txt")) else "NO TXT" |
| print(f" [{txt}] {p}: {k}:: {v[:140]}") |
|
|
| section("left to you") |
| print(" - fix every integrity ERROR; adjudicate 2b-2e; add retro-edges only where the\n" |
| " candidate note already supports them; verify the spot-audit sample and\n" |
| " report its error rate; then: python3 _scripts/end_of_wave.py --generate\n" |
| " and make the single batch commit.") |
| return 1 if ("--strict" in args and errs) else 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
