Nexhorizons-Public/claude-werkzeuge
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
claude-werkzeuge/.vault-tools/linkcheck/docs/plans/2026-09-29-waisen/task-04-bestandsskript.md
T
Pascal MichelandClaude Opus 5.5 fa1c26b407 Erste Fassung: Claude-Werkzeuge aus dem Vault 
.vault-tools (ohne trading-plattform-pruefung und watermarks-remover),
.claude/agents, .claude/skills, .claude/workflows, .claude/settings.json.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-14 11:27:59 +02:00

1315 lines
56 KiB
Markdown
Raw Permalink Blame History

---
type: plan-task
title: "Task 04 — Bestandsskript waisen_bestand.py mit Treiber"
status: draft
summary: "Legt waisen_bestand.py an, das verwaiste Notizen über Muster ihrem Hub zuordnet, im Probelauf nur auflistet und mit --anwenden erst sichert und dann anhängt, und faelle_waisen_bestand.py mit Git-Fällen und Rotlauf."
tags: [plan-task, vault-tools]
created: 2026-09-29
updated: 2026-09-30
modell: haiku
modell_begruendung: "Zwei neue Dateien stehen wörtlich im Plan und werden per Skript angelegt; keine typografischen Zeichen in den Codeblöcken."
---
Übersicht: [00-uebersicht.md](00-uebersicht.md)
# Task 04 — Bestandsskript
Globale Vorgaben: `00-uebersicht.md` im selben Ordner, Abschnitt „Globale Vorgaben“.
Voraussetzung: Task 01 ist umgesetzt. `waisen_bestand.py` importiert `waisen.py` aus demselben Ordner.
## Zieldateien
- `D:\Claude\.vault-tools\linkcheck\waisen_bestand.py` (neu)
- `D:\Claude\.vault-tools\linkcheck\faelle_waisen_bestand.py` (neu)
## Verbote
- `waisen_bestand.py` in diesem Task **nie** gegen den echten Vault fahren, auch nicht als Probelauf. Das ist Task 05.
- `waisen.py`, `linkcheck.py` und `waisen-ausnahmen.txt` bleiben unverändert.
- Kein `git` im echten Vault oder in einem echten Projekt-Repo. Die Git-Fälle des Treibers arbeiten nur im Wegwerfordner.
## Schritt 1 — Blöcke anwenden
```
python D:/Claude/.vault-tools/plan-kopie/plan_materialisiere.py D:/Claude/.vault-tools/linkcheck/docs/plans/2026-09-29-waisen D:/Claude task-04-bestandsskript.md
```
Erwartet: eine Zeile mit `'neu': 2` und die Schlusszeile `0 Befund(e).`
### `.vault-tools/linkcheck/waisen_bestand.py`
Die ganze Datei ist neu:
````python
"""Hängt verwaiste Notizen einmalig an ihren Hub an: nur anhängen, nie ersetzen.
Ersteller: Pascal Michel
Erstellt: 2026-09-29
Plan: docs/plans/2026-09-29-waisen/ im selben Ordner
Ohne --anwenden ist es ein Probelauf: Er listet je Zieldatei den Text, der
angehängt würde, und schreibt nichts. Mit --anwenden kopiert das Skript jede
Zieldatei zuerst in den Sicherungsordner außerhalb des Vaults, prüft jede
Kopie Byte für Byte und hängt erst danach an. Das Zeilenende jeder Datei
bleibt, wie es war. Kein Commit, kein git add.
REGELN, alle über Muster, ohne Namen einzelner Projekte oder Kunden
Code Projekte/<p>/docs/plans/<ordner>/<datei>.md
00-uebersicht.md desselben Ordners bekommt eine Zeile mit relativem Link
aufs Projekt-README, wenn sie es nicht schon verlinkt, und den Abschnitt
"Dateien in diesem Ordner" mit relativen Links auf jede .md im Ordner.
Taskdateien fasst das Skript nie an.
Code Projekte/<p>/CHANGELOG.md und jede Datei unter Code Projekte/<p>/docs/
außerhalb von Planordnern
eine Zeile mit relativem Link aufs Projekt-README.
docs/plans/<ordner>/<datei>.md an der Vault-Wurzel
wie ein Planordner in Code Projekte, aber die Zeile heißt "Vault:" und
verlinkt README.md der Vault-Wurzel.
jede andere Datei unter docs/ an der Vault-Wurzel
eine Zeile mit relativem Link auf README.md der Vault-Wurzel.
IT Workspace/**/_arbeitsstand/**
Planordner wie oben, aber der Link nach oben ist ein Wikilink auf die
einzige _MOC-*.md im Ordner über _arbeitsstand; jede andere Datei
bekommt eine Zeile mit diesem Wikilink.
IT Workspace/**/findings/<datei>.md
der Bericht im Ordner über findings (ABSCHLUSSBERICHT.md, sonst
FULL-AUDIT-REPORT.md) bekommt den Abschnitt "Befunddateien dieses Laufs"
mit einem Wikilink mit vollem Pfad je Datei.
AI/secondbrain/<ordner>/JJJJ-MM-TT-<thema>.md
eine Zeile "Tagesnotiz: [[Inbox/JJJJ-MM-TT]]", nur wenn die Tagesnotiz
existiert.
Alles andere kommt auf die Liste für den Koordinator. Geraten wird nichts.
ÜBERSPRUNGEN UND AUFGELISTET wird eine Zieldatei, die
* in einem Git-Repo im Vault liegt, auch dem der Vault-Wurzel, und dort in
irgendeinem Arbeitsbaum uncommittet geändert oder neu ist oder auf einem
anderen lokalen Zweig seit dem gemeinsamen Stand geändert wurde; was das
Repo ignoriert, zählt nicht als geändert,
* nicht als UTF-8 lesbar ist oder gemischte Zeilenenden hat,
* die anzuhängende Überschrift oder Linkzeile schon enthält.
Ein Git-Repo, das sich nicht prüfen lässt, sperrt alle seine Zieldateien.
BENANNTE LÜCKEN
* Welche Notiz eine Waise ist, entscheidet waisen.py mit dessen Lücken.
* Nur lokale Zweige zählen, entfernte nicht.
* Eine Datei, die zwischen dem Lesen und dem Anhängen geändert wird, bricht
den Lauf ab; was bis dahin angehängt war, nennt die Ausgabe.
Exit 0: Lauf durch. Exit 2: abgebrochen, die Ursache steht in der Ausgabe.
Aufruf:
python .vault-tools/linkcheck/waisen_bestand.py --vault D:/Claude
python .vault-tools/linkcheck/waisen_bestand.py --vault D:/Claude --anwenden --sicherung <ordner außerhalb des Vaults>
"""
import argparse
import os
import re
import shutil
import subprocess
import sys
import traceback
from dataclasses import dataclass, field
from pathlib import Path
from typing import Optional
from urllib.parse import quote
HIER = Path(__file__).resolve().parent
if str(HIER) not in sys.path:
sys.path.insert(0, str(HIER))
try:
import waisen
_IMPORTFEHLER = ""
except Exception as _fehler:
waisen = None
_IMPORTFEHLER = f"{type(_fehler).__name__}: {_fehler}"
ORDNER_KOPF = "## Dateien in diesem Ordner"
BEFUND_KOPF = "## Befunddateien dieses Laufs"
BERICHTE = ("ABSCHLUSSBERICHT.md", "FULL-AUDIT-REPORT.md")
_DATUM = re.compile(r"^(\d{4}-\d{2}-\d{2})")
GESCHRIEBEN = []
class Abbruch(Exception):
"""Der Lauf kann nicht sicher weiter."""
@dataclass
class Ziel:
rel: str
zeilen: list = field(default_factory=list)
ordner: Optional[str] = None
befunde: Optional[str] = None
ausloeser: list = field(default_factory=list)
hubs: set = field(default_factory=set)
gelistet: list = field(default_factory=list)
def existiert(vault: Path, rel: str) -> bool:
return (vault / rel).is_file()
def rel_link(von: str, zu: str) -> str:
start = von.split("/")[:-1]
ziel = zu.split("/")
gemeinsam = 0
while gemeinsam < min(len(start), len(ziel) - 1) and start[gemeinsam] == ziel[gemeinsam]:
gemeinsam += 1
teile = [".."] * (len(start) - gemeinsam) + ziel[gemeinsam:]
return quote("/".join(teile), safe="/")
def _code_projekt(rel: str, teile: list, vault: Path) -> tuple:
readme = "/".join(teile[:2]) + "/README.md"
innen = teile[2:]
if innen[:2] == ["docs", "plans"] and len(innen) == 4:
uebersicht = "/".join(teile[:-1]) + "/00-uebersicht.md"
if not existiert(vault, uebersicht):
return ("rest", "", "Planordner ohne 00-uebersicht.md", "")
if not existiert(vault, readme):
return ("rest", "", f"{readme} fehlt", "")
return ("ordner", uebersicht, f"Projekt: [README]({rel_link(uebersicht, readme)})", readme)
if innen[:2] == ["docs", "plans"] and len(innen) > 4:
return ("rest", "", "Plandatei tiefer als ein Ordner unter docs/plans", "")
if innen == ["CHANGELOG.md"] or (innen[:1] == ["docs"] and len(innen) >= 2):
if not existiert(vault, readme):
return ("rest", "", f"{readme} fehlt", "")
return ("zeile", rel, f"Projekt: [README]({rel_link(rel, readme)})", readme)
return ("rest", "", "keine Regel passt", "")
def _arbeitsstand(rel: str, teile: list, vault: Path) -> tuple:
stelle = teile.index("_arbeitsstand")
projekt = "/".join(teile[:stelle])
try:
mocs = sorted(
name for name in os.listdir(vault / projekt)
if name.startswith("_MOC-") and name.lower().endswith(".md") and (vault / projekt / name).is_file()
)
except OSError as fehler:
return ("rest", "", f"Projektordner nicht lesbar ({fehler})", "")
if len(mocs) != 1:
return ("rest", "", f"{len(mocs)} _MOC-Dateien in {projekt}, erwartet genau eine", "")
moc = f"{projekt}/{mocs[0]}"
zeile = f"Projekt: [[{moc[:-3]}]]"
innen = teile[stelle + 1:]
if innen[:2] == ["docs", "plans"] and len(innen) == 4:
uebersicht = "/".join(teile[:-1]) + "/00-uebersicht.md"
if not existiert(vault, uebersicht):
return ("rest", "", "Planordner ohne 00-uebersicht.md", "")
return ("ordner", uebersicht, zeile, moc)
if innen[:2] == ["docs", "plans"] and len(innen) > 4:
return ("rest", "", "Plandatei tiefer als ein Ordner unter docs/plans", "")
return ("zeile", rel, zeile, moc)
def _befund(rel: str, teile: list, vault: Path) -> tuple:
lauf = "/".join(teile[:-2])
for name in BERICHTE:
if existiert(vault, f"{lauf}/{name}"):
bericht = f"{lauf}/{name}"
return ("befund", bericht, "/".join(teile[:-1]), bericht)
return ("rest", "", f"kein Bericht ({' oder '.join(BERICHTE)}) in {lauf}", "")
def _dump(rel: str, teile: list, vault: Path) -> tuple:
treffer = _DATUM.match(teile[3])
if not treffer:
return ("rest", "", "Dump ohne Datum am Anfang des Dateinamens", "")
tag = treffer.group(1)
if not existiert(vault, f"Inbox/{tag}.md"):
return ("rest", "", f"Tagesnotiz Inbox/{tag}.md fehlt", "")
return ("zeile", rel, f"Tagesnotiz: [[Inbox/{tag}]]", f"Inbox/{tag}.md")
def _wurzel_docs(rel: str, teile: list, vault: Path) -> tuple:
# Pläne und Specs unter docs/ an der Vault-Wurzel: Hub ist README.md dort.
hub = "README.md"
if not existiert(vault, hub):
return ("rest", "", "README.md der Vault-Wurzel fehlt", "")
if teile[1] == "plans" and len(teile) == 4:
kopf = "/".join(teile[:-1]) + "/00-uebersicht.md"
if not existiert(vault, kopf):
return ("rest", "", "Planordner ohne 00-uebersicht.md", "")
return ("ordner", kopf, f"Vault: [README]({rel_link(kopf, hub)})", hub)
if teile[1] == "plans" and len(teile) > 4:
return ("rest", "", "Plandatei tiefer als ein Ordner unter docs/plans", "")
return ("zeile", rel, f"Vault: [README]({rel_link(rel, hub)})", hub)
def klassifiziere(rel: str, vault: Path) -> tuple:
"""Liefert (art, ziel, wert, hub). art ist zeile, ordner, befund oder rest."""
teile = rel.split("/")
if teile[0] == "Code Projekte" and len(teile) >= 3:
return _code_projekt(rel, teile, vault)
if teile[0] == "IT Workspace" and "_arbeitsstand" in teile[1:-1]:
return _arbeitsstand(rel, teile, vault)
if teile[0] == "IT Workspace" and len(teile) >= 3 and teile[-2] == "findings":
return _befund(rel, teile, vault)
if teile[:2] == ["AI", "secondbrain"] and len(teile) == 4:
return _dump(rel, teile, vault)
if teile[0] == "docs" and len(teile) >= 2:
return _wurzel_docs(rel, teile, vault)
return ("rest", "", "keine Regel passt", "")
def plane(vault: Path, ergebnis) -> tuple:
ziele = {}
rest = []
for rel in ergebnis.waisen:
art, ziel_rel, wert, hub = klassifiziere(rel, vault)
if art == "rest":
rest.append((rel, wert))
continue
ziel = ziele.setdefault(ziel_rel, Ziel(ziel_rel))
ziel.ausloeser.append(rel)
ziel.hubs.add(hub)
if art == "befund":
ziel.befunde = wert
continue
if art == "ordner":
ziel.ordner = ziel_rel.rsplit("/", 1)[0]
if hub in ergebnis.ausgehend.get(ziel_rel, set()):
continue
if wert not in ziel.zeilen:
ziel.zeilen.append(wert)
return ziele, rest
def md_dateien(vault: Path, ordner: str) -> list:
pfad = vault / ordner
return sorted(
name for name in os.listdir(pfad)
if name.lower().endswith(".md") and not name.startswith(".") and (pfad / name).is_file()
)
def anhang(vault: Path, ziel: Ziel) -> list:
zeilen = list(ziel.zeilen)
if ziel.ordner is not None:
namen = [n for n in md_dateien(vault, ziel.ordner) if n != "00-uebersicht.md"]
if namen:
if zeilen:
zeilen.append("")
zeilen += [ORDNER_KOPF, ""]
zeilen += [f"- [{n}]({quote(n, safe='')})" for n in namen]
ziel.gelistet += [f"{ziel.ordner}/{n}" for n in namen]
if ziel.befunde is not None:
namen = md_dateien(vault, ziel.befunde)
if namen:
if zeilen:
zeilen.append("")
zeilen += [BEFUND_KOPF, ""]
zeilen += [f"- [[{ziel.befunde}/{n[:-3]}]]" for n in namen]
ziel.gelistet += [f"{ziel.befunde}/{n}" for n in namen]
return zeilen
def pruefe_ziel(vault: Path, rel: str, zeilen: list) -> tuple:
"""Liefert (Grund zum Überspringen oder None, alter Inhalt, Zeilenende)."""
alt = (vault / rel).read_bytes()
try:
text = alt.decode("utf-8")
except UnicodeDecodeError:
return "nicht als UTF-8 lesbar", alt, ""
crlf = alt.count(b"\r\n")
lf = alt.count(b"\n") - crlf
if crlf and lf:
return "gemischte Zeilenenden", alt, ""
ende = "\r\n" if crlf else "\n"
vorhanden = text.replace("\r\n", "\n").split("\n")
for zeile in zeilen:
if zeile and not zeile.startswith("- "):
if zeile in vorhanden:
return f"enthält schon die Zeile {zeile!r}", alt, ende
return None, alt, ende
def anhang_bytes(alt: bytes, zeilen: list, ende: str) -> bytes:
vorne = ende if alt and not alt.endswith(b"\n") else ""
return (vorne + ende + ende.join(zeilen) + ende).encode("utf-8")
def repo_von(vault: Path, rel: str) -> Optional[Path]:
ordner = (vault / rel).parent
# Auch die Vault-Wurzel kann ein Repo sein; über ihr wird nicht gesucht.
while ordner == vault or vault in ordner.parents:
if (ordner / ".git").exists():
return ordner
if ordner == vault:
return None
ordner = ordner.parent
return None
def git(ordner: Path, *argumente: str) -> bytes:
umgebung = dict(os.environ)
# Kein Index-Auffrischen: der Probelauf schreibt auch in .git nichts.
umgebung["GIT_OPTIONAL_LOCKS"] = "0"
try:
lauf = subprocess.run(
["git", "-C", str(ordner), *argumente],
capture_output=True,
stdin=subprocess.DEVNULL,
timeout=120,
env=umgebung,
)
except (OSError, subprocess.TimeoutExpired) as fehler:
raise Abbruch(f"git {' '.join(argumente)} in {ordner}: {fehler}") from fehler
if lauf.returncode != 0:
meldung = lauf.stderr.decode("utf-8", errors="replace").strip()
raise Abbruch(f"git {' '.join(argumente)} in {ordner}: Exit {lauf.returncode}: {meldung}")
return lauf.stdout
def geaenderte_pfade(repo: Path) -> dict:
"""Pfad relativ zum Repo, klein geschrieben, und wo er geändert ist."""
wo = {}
liste = git(repo, "worktree", "list", "--porcelain").decode("utf-8", errors="replace")
baeume = [z[len("worktree "):].strip() for z in liste.split("\n") if z.startswith("worktree ")]
if not baeume:
raise Abbruch("git worktree list nennt keinen Arbeitsbaum")
for baum in baeume:
roh = git(Path(baum), "status", "--porcelain", "-z", "--untracked-files=all")
eintraege = roh.decode("utf-8", errors="replace").split("\0")
i = 0
while i < len(eintraege):
eintrag = eintraege[i]
i += 1
if len(eintrag) < 4:
continue
wo.setdefault(eintrag[3:].lower(), f"Arbeitsbaum {baum}")
if "R" in eintrag[:2] or "C" in eintrag[:2]:
if i < len(eintraege) and eintraege[i]:
wo.setdefault(eintraege[i].lower(), f"Arbeitsbaum {baum}")
i += 1
aktuell = git(repo, "rev-parse", "--abbrev-ref", "HEAD").decode("utf-8", errors="replace").strip()
zweige = git(repo, "for-each-ref", "--format=%(refname:short)", "refs/heads/").decode("utf-8", errors="replace")
for zweig in (z.strip() for z in zweige.split("\n")):
if not zweig or zweig == aktuell:
continue
diff = git(repo, "diff", "--name-only", "-z", f"HEAD...{zweig}", "--")
for pfad in diff.decode("utf-8", errors="replace").split("\0"):
if pfad:
wo.setdefault(pfad.lower(), f"Zweig {zweig}")
return wo
def pruefe_alle(vault: Path, ziele: dict) -> tuple:
repos = {}
fertig = []
uebersprungen = []
for rel in sorted(ziele):
ziel = ziele[rel]
zeilen = anhang(vault, ziel)
repo = repo_von(vault, rel)
if repo is not None:
if repo not in repos:
try:
repos[repo] = geaenderte_pfade(repo)
except Abbruch as fehler:
repos[repo] = str(fehler)
stand = repos[repo]
if isinstance(stand, str):
uebersprungen.append((ziel, f"Git-Repo nicht prüfbar: {stand}"))
continue
innen = (vault / rel).relative_to(repo).as_posix().lower()
if innen in stand:
uebersprungen.append((ziel, f"in Git geändert ({stand[innen]})"))
continue
grund, alt, ende = pruefe_ziel(vault, rel, zeilen)
if grund:
uebersprungen.append((ziel, grund))
continue
fertig.append((ziel, zeilen, alt, ende))
return fertig, uebersprungen
def zeige(vault: Path, anwenden: bool, vorher: int, fertig: list, uebersprungen: list, rest: list, mitverbunden: int) -> None:
print(f"# Bestandslauf - {'Anwenden' if anwenden else 'Probelauf'} - {vault}")
print(f"Waisen außerhalb der Ausnahmen vorher: {vorher}")
print()
print(f"## Anhänge ({len(fertig)} Dateien)")
for ziel, zeilen, _alt, ende in fertig:
art = "CRLF" if ende == "\r\n" else "LF"
print(f"ZIEL {ziel.rel} [{art}] wegen {len(ziel.ausloeser)} Waise(n)")
for zeile in zeilen:
print(f" | {zeile}")
print()
print(f"## Übersprungen ({len(uebersprungen)})")
for ziel, grund in uebersprungen:
print(f"UEBERSPRUNGEN {ziel.rel}: {grund} (betrifft {len(ziel.ausloeser)} Waise(n))")
print()
print(f"## Liste für den Koordinator ({len(rest)})")
for rel, grund in rest:
print(f"REST {rel}: {grund}")
print(f"Durch Anhänge mitverbunden, ohne eigene Regel: {mitverbunden}")
def sichern_und_anhaengen(vault: Path, sicherung: Path, fertig: list) -> None:
sicherung.mkdir(parents=True)
for ziel, _zeilen, alt, _ende in fertig:
kopie = sicherung / ziel.rel
kopie.parent.mkdir(parents=True, exist_ok=True)
shutil.copy2(vault / ziel.rel, kopie)
if kopie.read_bytes() != alt:
raise Abbruch(f"Sicherung weicht vom Original ab: {kopie}")
for ziel, zeilen, alt, ende in fertig:
pfad = vault / ziel.rel
if pfad.read_bytes() != alt:
raise Abbruch(f"{ziel.rel} hat sich seit dem Lesen geändert")
neu = anhang_bytes(alt, zeilen, ende)
with open(pfad, "ab") as datei:
datei.write(neu)
GESCHRIEBEN.append(ziel.rel)
if pfad.read_bytes() != alt + neu:
raise Abbruch(f"{ziel.rel}: Inhalt nach dem Anhängen weicht ab")
(sicherung / "GEAENDERT.txt").write_text("\n".join(GESCHRIEBEN) + "\n", encoding="utf-8", newline="\n")
def lauf(vault: Path, ausnahmen: Path, anwenden: bool, sicherung) -> int:
GESCHRIEBEN.clear()
if waisen is None:
raise Abbruch(f"waisen.py nicht importierbar ({_IMPORTFEHLER})")
sicherung_pfad = None
if anwenden:
if not sicherung:
raise Abbruch("--anwenden braucht --sicherung mit einem Ordner außerhalb des Vaults")
sicherung_pfad = Path(os.path.abspath(sicherung)).resolve()
if sicherung_pfad == vault or vault in sicherung_pfad.parents:
raise Abbruch(f"Sicherungsordner liegt im Vault: {sicherung_pfad}")
if sicherung_pfad.exists():
raise Abbruch(f"Sicherungsordner existiert schon: {sicherung_pfad}")
ergebnis = waisen.analysiere(vault, ausnahmen)
ziele, rest = plane(vault, ergebnis)
fertig, uebersprungen = pruefe_alle(vault, ziele)
verbunden = set()
for ziel, _zeilen, _alt, _ende in fertig:
verbunden.add(ziel.rel)
verbunden.update(ziel.hubs)
verbunden.update(ziel.gelistet)
anzahl = len(rest)
rest = [(rel, grund) for rel, grund in rest if rel not in verbunden]
zeige(vault, anwenden, len(ergebnis.waisen), fertig, uebersprungen, rest, anzahl - len(rest))
if anwenden:
sichern_und_anhaengen(vault, sicherung_pfad, fertig)
nachher = waisen.analysiere(vault, ausnahmen)
print()
print(f"Angehängt an {len(GESCHRIEBEN)} Dateien. Sicherung und GEAENDERT.txt: {sicherung_pfad}")
print(f"Waisen außerhalb der Ausnahmen nachher: {len(nachher.waisen)}")
return 0
def main(argv=None) -> int:
zerleger = argparse.ArgumentParser(description="Hängt verwaiste Notizen einmalig an ihren Hub an")
zerleger.add_argument("--vault", required=True)
zerleger.add_argument("--ausnahmen", default=str(HIER / "waisen-ausnahmen.txt"))
zerleger.add_argument("--anwenden", action="store_true")
zerleger.add_argument("--sicherung")
args = zerleger.parse_args(argv)
vault = Path(os.path.abspath(args.vault)).resolve()
try:
return lauf(vault, Path(args.ausnahmen), args.anwenden, args.sicherung)
except Exception as fehler:
erwartet = isinstance(fehler, Abbruch) or (waisen is not None and isinstance(fehler, waisen.Abbruch))
art = "" if erwartet else f"{type(fehler).__name__}: "
print(f"Bestandslauf - ABGEBROCHEN: {art}{fehler}")
if not erwartet:
print(traceback.format_exc())
if GESCHRIEBEN:
print(f"Vor dem Abbruch schon angehängt ({len(GESCHRIEBEN)}), die Sicherung liegt vor:")
for rel in GESCHRIEBEN:
print(f" - {rel}")
return 2
if __name__ == "__main__":
try:
sys.stdout.reconfigure(encoding="utf-8")
except AttributeError:
pass
sys.exit(main())
````
### `.vault-tools/linkcheck/faelle_waisen_bestand.py`
Die ganze Datei ist neu:
````python
"""Fährt die Angriffsliste gegen waisen_bestand.py, je Fall auf einem Wegwerf-Vault.
Ersteller: Pascal Michel
Erstellt: 2026-09-29
Plan: docs/plans/2026-09-29-waisen/ im selben Ordner
Grundlinie zuerst: Der Probelauf über den unbeschädigten Wegwerf-Vault muss
genau die erwarteten Anhänge und genau die erwartete Liste liefern und darf
nichts ändern. Sonst misst der Rest nichts.
Je Fall eine frische Kopie der Grundlinie, genau eine Änderung, das Skript als
eigener Prozess. Die Git-Fälle legen im Wegwerf-Vault ein Repo mit Zweig oder
Arbeitsbaum an und brauchen git im PATH. Verglichen wird jede Datei des
Wegwerf-Vaults vor und nach dem Lauf, Byte für Byte.
Zwei Fälle laufen über HUELLE: Sie lädt waisen_bestand.py in einen eigenen
Prozess und setzt entweder einen fremden Schreiber ein, der nach der Sicherung
an CHANGELOG.md anhängt, oder schreibt je git-Aufruf den Wert von
GIT_OPTIONAL_LOCKS mit.
--rotlauf baut jeden Mutanten aus MUTANTEN in eine Kopie des Skripts und fährt
die genannten Fälle dagegen. Getötet heißt: jeder genannte Fall schlägt fehl.
Aufruf:
python .vault-tools/linkcheck/faelle_waisen_bestand.py
python .vault-tools/linkcheck/faelle_waisen_bestand.py --rotlauf
"""
import os
import shutil
import stat
import subprocess
import sys
import tempfile
import time
from dataclasses import dataclass, field
from pathlib import Path
from typing import Callable, Optional
HIER = Path(__file__).resolve().parent
BESTAND = HIER / "waisen_bestand.py"
BEGLEITER = [HIER / "waisen.py", HIER / "linkcheck.py", HIER / "waisen-ausnahmen.txt"]
P = "Code Projekte/active - Alpha"
E = P + "/docs/plans/2026-01-01-eins"
S = "IT Workspace/SEO/kunde-audit/15012026"
X = "IT Workspace/Thema/Projekt X"
XP = X + "/_arbeitsstand/docs/plans/2026-01-03-p"
W = "docs/plans/2026-01-04-w"
SPEC = "docs/specs/2026-01-04-spec.md"
NEU = P + "/docs/plans/2026-01-09-neu"
DUMP = "AI/secondbrain/alpha-memory/2026-01-01-thema.md"
DUMP_OHNE = "AI/secondbrain/alpha-memory/2026-01-05-ohne.md"
UMLAUT = "task-09-prüfung x.md"
UMLAUT_LINK = "task-09-pr%C3%BCfung%20x.md"
ORDNER_KOPF = "## Dateien in diesem Ordner"
BEFUND_KOPF = "## Befunddateien dieses Laufs"
ZIELE = {
P + "/CHANGELOG.md": ["Projekt: [README](README.md)"],
P + "/docs/code/modul.md": ["Projekt: [README](../../README.md)"],
P + "/docs/lose.md": ["Projekt: [README](../README.md)"],
P + "/docs/plans/2026-01-02-einzel.md": ["Projekt: [README](../../README.md)"],
E + "/00-uebersicht.md": ["Projekt: [README](../../../README.md)", "", ORDNER_KOPF, "",
"- [task-01-a.md](task-01-a.md)", f"- [{UMLAUT}]({UMLAUT_LINK})"],
DUMP: ["Tagesnotiz: [[Inbox/2026-01-01]]"],
S + "/ABSCHLUSSBERICHT.md": [BEFUND_KOPF, "", f"- [[{S}/findings/a]]", f"- [[{S}/findings/b]]"],
X + "/_arbeitsstand/notiz.md": [f"Projekt: [[{X}/_MOC-projekt-x]]"],
XP + "/00-uebersicht.md": [f"Projekt: [[{X}/_MOC-projekt-x]]", "", ORDNER_KOPF, "",
"- [task-01-t.md](task-01-t.md)"],
W + "/00-uebersicht.md": ["Vault: [README](../../../README.md)", "", ORDNER_KOPF, "",
"- [task-01-w.md](task-01-w.md)"],
SPEC: ["Vault: [README](../../README.md)"],
}
REST = {
P + "/notizen.md": "keine Regel passt",
DUMP_OHNE: "Tagesnotiz Inbox/2026-01-05.md fehlt",
W + "/befunde/b1.md": "Plandatei tiefer als ein Ordner unter docs/plans",
}
HUELLE = '''"""Huelle aus faelle_waisen_bestand.py: laedt waisen_bestand.py und biegt zwei Stellen um."""
import importlib.util
import os
import subprocess
import sys
from pathlib import Path
skript, art, *rest = sys.argv[1:]
# Die Variable darf nicht schon von aussen kommen, sonst misst der Fall die Shell.
os.environ.pop("GIT_OPTIONAL_LOCKS", None)
spec = importlib.util.spec_from_file_location("waisen_bestand_huelle", skript)
modul = importlib.util.module_from_spec(spec)
# Vor exec_module eintragen: dataclasses sucht das Modul in sys.modules.
sys.modules["waisen_bestand_huelle"] = modul
spec.loader.exec_module(modul)
aufrufe = []
echt_run = subprocess.run
echt_copy2 = modul.shutil.copy2
def run(befehl, *a, **k):
# Git-Double: merkt sich je git-Aufruf den Wert von GIT_OPTIONAL_LOCKS.
if befehl and befehl[0] == "git":
aufrufe.append((k.get("env") or os.environ).get("GIT_OPTIONAL_LOCKS"))
return echt_run(befehl, *a, **k)
def copy2(quelle, ziel, *a, **k):
# Fremder Schreiber: haengt nach der Sicherung von CHANGELOG.md etwas an.
ergebnis = echt_copy2(quelle, ziel, *a, **k)
if art == "fremd" and Path(quelle).name == "CHANGELOG.md":
with open(quelle, "ab") as datei:
datei.write(b"fremd")
return ergebnis
subprocess.run = run
modul.shutil.copy2 = copy2
sys.stdout.reconfigure(encoding="utf-8")
code = modul.main(rest)
ohne = [wert for wert in aufrufe if wert != "0"]
if aufrufe and not ohne:
print("HUELLE git ok")
else:
print(f"HUELLE git: {len(aufrufe)} Aufrufe, {len(ohne)} ohne GIT_OPTIONAL_LOCKS=0")
raise SystemExit(code)
'''
def schreibe(v: Path, rel: str, inhalt) -> None:
# Immer Bytes: write_text würde unter Windows jedes LF zu CRLF machen.
pfad = v / rel
pfad.parent.mkdir(parents=True, exist_ok=True)
pfad.write_bytes(inhalt if isinstance(inhalt, bytes) else inhalt.encode("utf-8"))
def haenge_an(v: Path, rel: str, inhalt: bytes) -> None:
with open(v / rel, "ab") as datei:
datei.write(inhalt)
def _schreibbar(funktion, pfad, _info) -> None:
# Git legt Objektdateien schreibgeschützt an; rmtree scheitert sonst unter Windows.
os.chmod(pfad, stat.S_IWRITE)
funktion(pfad)
def entferne(pfad: Path) -> None:
if not pfad.exists():
return
if sys.version_info >= (3, 12):
shutil.rmtree(pfad, onexc=_schreibbar)
else:
shutil.rmtree(pfad, onerror=_schreibbar)
def nichts(v: Path) -> None:
return None
def baue_grundlinie(v: Path) -> None:
schreibe(v, ".obsidian/app.json", '{"userIgnoreFilters": ["_index/"]}')
schreibe(v, "Wissen/start.md",
f"[[{P}/README]]\n[[IT Workspace/SEO/_MOC-seo]]\n[[{X}/_MOC-projekt-x]]\n[[README]]\n")
schreibe(v, "README.md", "# Vault\n")
schreibe(v, P + "/README.md", "# Alpha\n")
schreibe(v, P + "/CHANGELOG.md", "# Changelog")
schreibe(v, P + "/notizen.md", "# Notizen\n")
schreibe(v, P + "/data/2026-01-01.md", "# Auswertung\n")
schreibe(v, P + "/docs/code/modul.md", b"# Modul\r\n\r\nText\r\n")
schreibe(v, P + "/docs/lose.md", "# Lose\n")
schreibe(v, P + "/docs/plans/2026-01-02-einzel.md", "# Einzel\n")
schreibe(v, E + "/00-uebersicht.md", "# Eins\n")
schreibe(v, E + "/task-01-a.md", "# A\n")
schreibe(v, E + "/" + UMLAUT, "# Z\n")
schreibe(v, DUMP, "# Dump\n")
schreibe(v, DUMP_OHNE, "# Dump\n")
schreibe(v, "Inbox/2026-01-01.md", "# Tag\n")
schreibe(v, "IT Workspace/SEO/_MOC-seo.md", f"[[{S}/ABSCHLUSSBERICHT]]\n")
schreibe(v, S + "/ABSCHLUSSBERICHT.md", "# Bericht\n")
schreibe(v, S + "/findings/a.md", "# A\n")
schreibe(v, S + "/findings/b.md", "# B\n")
schreibe(v, X + "/_MOC-projekt-x.md", "# X\n")
schreibe(v, X + "/_arbeitsstand/notiz.md", "# N\n")
schreibe(v, XP + "/00-uebersicht.md", "# P\n")
schreibe(v, XP + "/task-01-t.md", "# T\n")
schreibe(v, W + "/00-uebersicht.md", "# W\n")
schreibe(v, W + "/task-01-w.md", "# T\n")
schreibe(v, W + "/befunde/b1.md", "# B\n")
schreibe(v, SPEC, "# Spec\n")
schreibe(v, "Bookstack/archiv/seite.md", "# S\n")
schreibe(v, "_index/INDEX.md", "# I\n")
def git(ordner: Path, *argumente: str) -> None:
lauf = subprocess.run(
["git", "-C", str(ordner), "-c", "user.name=Faelle", "-c", "[email protected]",
"-c", "commit.gpgsign=false", *argumente],
capture_output=True,
stdin=subprocess.DEVNULL,
)
if lauf.returncode != 0:
raise RuntimeError(f"git {' '.join(argumente)}: {lauf.stderr.decode('utf-8', errors='replace')}")
def repo_anlegen(v: Path, ohne: Optional[str] = None) -> Path:
repo = v / P
git(repo, "init", "-q", "-b", "main")
git(repo, "config", "core.autocrlf", "false")
git(repo, "add", "-A")
if ohne:
git(repo, "rm", "-q", "--cached", ohne)
git(repo, "commit", "-q", "-m", "Stand")
return repo
def zweig_aendert(v: Path) -> None:
repo = repo_anlegen(v)
git(repo, "checkout", "-q", "-b", "neben")
schreibe(v, E + "/00-uebersicht.md", "# Eins auf dem Zweig\n")
git(repo, "commit", "-q", "-am", "Zweig")
git(repo, "checkout", "-q", "main")
def arbeitsbaum_aendert(v: Path) -> None:
repo = repo_anlegen(v)
baum = v / ".arbeitsbaeume" / "wb"
git(repo, "worktree", "add", "-q", "-b", "wb", str(baum))
haenge_an(baum, "docs/plans/2026-01-01-eins/00-uebersicht.md", b"offen\n")
def eigener_baum_aendert(v: Path) -> None:
repo_anlegen(v)
haenge_an(v, E + "/00-uebersicht.md", b"offen\n")
def nie_committet(v: Path) -> None:
repo_anlegen(v, ohne="CHANGELOG.md")
def sauberes_repo(v: Path) -> None:
repo_anlegen(v)
def neuer_planordner(v: Path) -> None:
# Ganz ungetrackter Ordner: im Modus normal nennt git nur den Ordner.
repo_anlegen(v)
schreibe(v, NEU + "/00-uebersicht.md", "# Neu\n")
schreibe(v, NEU + "/task-01-x.md", "# X\n")
def umbenannt_im_index(v: Path) -> None:
# Der alte Pfad ab/CHANGELOG.md ohne seine ersten drei Zeichen wäre CHANGELOG.md.
schreibe(v, P + "/ab/CHANGELOG.md", "# Alt\n")
repo = repo_anlegen(v)
git(repo, "mv", "ab/CHANGELOG.md", "ab/neu.md")
# Ohne erkannte Umbenennung misst der Fall nichts.
status = subprocess.run(["git", "-C", str(repo), "status", "--porcelain"],
capture_output=True, stdin=subprocess.DEVNULL).stdout
if not status.startswith(b"R "):
raise RuntimeError(f"git meldet keine Umbenennung: {status!r}")
def wurzel_repo(v: Path, ignorieren: str) -> None:
schreibe(v, ".gitignore", ignorieren)
git(v, "init", "-q", "-b", "main")
git(v, "config", "core.autocrlf", "false")
git(v, "add", ".gitignore")
git(v, "commit", "-q", "-m", "Stand")
def wurzel_ignoriert_alles(v: Path) -> None:
# Wie die Positivliste der Vault-Wurzel: alles ignoriert außer .gitignore.
wurzel_repo(v, "/*\n!/.gitignore\n")
def wurzel_docs_offen(v: Path) -> None:
# docs/ ist nicht ignoriert, seine Dateien sind also neu im Repo der Wurzel.
wurzel_repo(v, "/*\n!/.gitignore\n!/docs/\n")
def abbild(v: Path) -> dict:
ergebnis = {}
for pfad in sorted(v.rglob("*")):
rel = pfad.relative_to(v)
if ".git" in rel.parts or not pfad.is_file():
continue
ergebnis[rel.as_posix()] = pfad.read_bytes()
return ergebnis
@dataclass
class Fall:
name: str
aendern: Callable = nichts
# probe, anwenden, zweimal, ohne_sicherung, sicherung_da, sicherung_im_vault, anwenden_abbruch, anwenden_fremd
modus: str = "probe"
code: int = 0
ziele: Optional[dict] = None
ziel_zeilen: dict = field(default_factory=dict)
mit_ziel: list = field(default_factory=list)
ohne_ziel: list = field(default_factory=list)
rest: Optional[dict] = None
mit_rest: dict = field(default_factory=dict)
ueber: dict = field(default_factory=dict)
texte: list = field(default_factory=list)
nachher: dict = field(default_factory=dict)
# leer: Skript direkt; fremd oder sperre: über HUELLE
huelle: str = ""
GRUNDLINIE = Fall("GRUNDLINIE", ziele=ZIELE, rest=REST,
texte=["Waisen außerhalb der Ausnahmen vorher: 20",
"Durch Anhänge mitverbunden, ohne eigene Regel: 1"])
FAELLE = [
Fall("anwenden | schreibt genau die erwarteten Bytes", modus="anwenden", ziele=ZIELE, rest=REST,
texte=["Waisen außerhalb der Ausnahmen nachher: 3"],
nachher={
P + "/CHANGELOG.md": b"# Changelog\n\nProjekt: [README](README.md)\n",
P + "/docs/code/modul.md": b"# Modul\r\n\r\nText\r\n\r\nProjekt: [README](../../README.md)\r\n",
E + "/00-uebersicht.md": (
"# Eins\n\nProjekt: [README](../../../README.md)\n\n## Dateien in diesem Ordner\n\n"
"- [task-01-a.md](task-01-a.md)\n- [task-09-prüfung x.md](task-09-pr%C3%BCfung%20x.md)\n"
).encode("utf-8"),
}),
Fall("anwenden | zweiter Lauf findet nichts mehr", modus="zweimal", ziele=ZIELE, rest=REST),
Fall("anwenden | ohne --sicherung bricht ab", modus="ohne_sicherung", code=2,
texte=["braucht --sicherung"]),
Fall("anwenden | Sicherungsordner existiert schon", modus="sicherung_da", code=2,
texte=["existiert schon"]),
Fall("anwenden | Sicherungsordner im Vault", modus="sicherung_im_vault", code=2,
texte=["liegt im Vault"]),
Fall("anwenden | Befund des Zaehlers bricht ohne Schreiben ab",
lambda v: entferne(v / ".obsidian"), modus="anwenden_abbruch", code=2,
texte=["Bestandslauf - ABGEBROCHEN", "Ordner .obsidian fehlt"]),
Fall("anwenden | fremder Schreiber zwischen Lesen und Anhaengen bricht ab", modus="anwenden_fremd",
huelle="fremd", code=2,
texte=["hat sich seit dem Lesen geändert", "Vor dem Abbruch schon angehängt (1)"],
nachher={
DUMP: b"# Dump\n\nTagesnotiz: [[Inbox/2026-01-01]]\n",
P + "/CHANGELOG.md": b"# Changelogfremd",
}),
Fall("zeilenende | gemischte Zeilenenden werden uebersprungen",
lambda v: schreibe(v, P + "/docs/code/modul.md", b"# Modul\r\nText\n"),
ueber={P + "/docs/code/modul.md": "gemischte Zeilenenden"}, ohne_ziel=[P + "/docs/code/modul.md"]),
Fall("kodierung | kein UTF-8 wird uebersprungen",
lambda v: schreibe(v, P + "/docs/plans/2026-01-02-einzel.md", b"# Einzel \xff\n"),
ueber={P + "/docs/plans/2026-01-02-einzel.md": "nicht als UTF-8 lesbar"}),
Fall("git | anderer Zweig hat die Uebersicht geaendert", zweig_aendert,
ueber={E + "/00-uebersicht.md": "Zweig neben"}, mit_ziel=[P + "/CHANGELOG.md"]),
Fall("git | anderer Arbeitsbaum hat die Uebersicht uncommittet geaendert", arbeitsbaum_aendert,
ueber={E + "/00-uebersicht.md": "Arbeitsbaum"}, mit_ziel=[P + "/CHANGELOG.md"]),
Fall("git | Uebersicht im eigenen Arbeitsbaum geaendert", eigener_baum_aendert,
ueber={E + "/00-uebersicht.md": "Arbeitsbaum"}),
Fall("git | nie committete Datei zaehlt als geaendert", nie_committet,
ueber={P + "/CHANGELOG.md": "Arbeitsbaum"}),
Fall("git | sauberes Repo ohne Zweig wird angehaengt", sauberes_repo, ziele=ZIELE, rest=REST),
Fall("git | ungetrackter Planordner zaehlt je Datei", neuer_planordner,
ueber={NEU + "/00-uebersicht.md": "Arbeitsbaum"}, mit_ziel=[P + "/CHANGELOG.md"]),
Fall("git | Umbenennung: alter Pfad ist kein eigener Eintrag", umbenannt_im_index,
mit_ziel=[P + "/CHANGELOG.md"]),
Fall("git | jeder git-Aufruf mit GIT_OPTIONAL_LOCKS=0", sauberes_repo, huelle="sperre",
ziele=ZIELE, rest=REST, texte=["HUELLE git ok"]),
Fall("git | Vault-Wurzel als Repo, ignorierte Dateien zaehlen nicht", wurzel_ignoriert_alles,
ziele=ZIELE, rest=REST),
Fall("git | Vault-Wurzel als Repo, docs/ nicht ignoriert", wurzel_docs_offen,
ueber={W + "/00-uebersicht.md": "Arbeitsbaum", SPEC: "Arbeitsbaum"},
mit_ziel=[DUMP, P + "/CHANGELOG.md"]),
Fall("regel | Planordner ohne 00-uebersicht.md",
lambda v: (v / E / "00-uebersicht.md").unlink(),
mit_rest={E + "/task-01-a.md": "Planordner ohne 00-uebersicht.md",
E + "/" + UMLAUT: "Planordner ohne 00-uebersicht.md"}),
Fall("regel | Planordner nur mit Uebersicht",
lambda v: ((v / E / "task-01-a.md").unlink(), (v / E / UMLAUT).unlink()),
ziel_zeilen={E + "/00-uebersicht.md": ["Projekt: [README](../../../README.md)"]}),
Fall("regel | Projekt ohne README",
lambda v: (v / P / "README.md").unlink(),
mit_rest={P + "/CHANGELOG.md": "README.md fehlt", E + "/task-01-a.md": "README.md fehlt"},
ohne_ziel=[P + "/CHANGELOG.md", E + "/00-uebersicht.md"]),
Fall("regel | Befunde ohne Bericht",
lambda v: (v / S / "ABSCHLUSSBERICHT.md").unlink(),
mit_rest={S + "/findings/a.md": "kein Bericht", S + "/findings/b.md": "kein Bericht"}),
Fall("regel | FULL-AUDIT-REPORT als Bericht",
lambda v: (v / S / "ABSCHLUSSBERICHT.md").rename(v / S / "FULL-AUDIT-REPORT.md"),
ziel_zeilen={S + "/FULL-AUDIT-REPORT.md": [BEFUND_KOPF, "", f"- [[{S}/findings/a]]",
f"- [[{S}/findings/b]]"]},
ohne_ziel=[S + "/ABSCHLUSSBERICHT.md"]),
Fall("regel | zwei MOC-Dateien ueber _arbeitsstand",
lambda v: schreibe(v, X + "/_MOC-zwei.md", "# Z\n"),
mit_rest={X + "/_arbeitsstand/notiz.md": "2 _MOC-Dateien"}),
Fall("regel | Abschnitt schon vorhanden",
lambda v: schreibe(v, E + "/00-uebersicht.md", "# Eins\n\n## Dateien in diesem Ordner\n\n- alt\n"),
ueber={E + "/00-uebersicht.md": "enthält schon"}),
Fall("regel | Uebersicht verlinkt das README schon",
lambda v: schreibe(v, E + "/00-uebersicht.md", "# Eins\n\n[README](../../../README.md)\n"),
ziel_zeilen={E + "/00-uebersicht.md": [ORDNER_KOPF, "", "- [task-01-a.md](task-01-a.md)",
f"- [{UMLAUT}]({UMLAUT_LINK})"]}),
Fall("regel | Dump tiefer als ein Ordner",
lambda v: schreibe(v, "AI/secondbrain/alpha-memory/drehbuecher/2026-01-01-x.md", "# D\n"),
mit_rest={"AI/secondbrain/alpha-memory/drehbuecher/2026-01-01-x.md": "keine Regel passt"}),
Fall("regel | Vault-Wurzel ohne README",
lambda v: (v / "README.md").unlink(),
mit_rest={W + "/task-01-w.md": "README.md der Vault-Wurzel fehlt",
SPEC: "README.md der Vault-Wurzel fehlt"},
ohne_ziel=[W + "/00-uebersicht.md", SPEC]),
Fall("regel | Wurzel-Planordner ohne 00-uebersicht.md",
lambda v: (v / W / "00-uebersicht.md").unlink(),
mit_rest={W + "/task-01-w.md": "Planordner ohne 00-uebersicht.md"}),
]
ALLE = [GRUNDLINIE] + FAELLE
# (Name, Zeile in waisen_bestand.py, Ersatzzeile, Fälle, die rot werden müssen)
MUTANTEN = [
("Zeilenende immer LF",
r' ende = "\r\n" if crlf else "\n"',
r' ende = "\n"',
["anwenden | schreibt genau die erwarteten Bytes"]),
("Git-Pruefung aus",
" repo = repo_von(vault, rel)",
" repo = None",
["git | anderer Zweig hat die Uebersicht geaendert",
"git | anderer Arbeitsbaum hat die Uebersicht uncommittet geaendert",
"git | Uebersicht im eigenen Arbeitsbaum geaendert",
"git | nie committete Datei zaehlt als geaendert"]),
("vorhandene Zeile nicht erkannt",
" if zeile in vorhanden:",
" if False:",
["regel | Abschnitt schon vorhanden"]),
("Sicherung leer",
" shutil.copy2(vault / ziel.rel, kopie)",
" kopie.write_bytes(b\"\")",
["anwenden | schreibt genau die erwarteten Bytes"]),
("Liste nicht gefiltert",
" rest = [(rel, grund) for rel, grund in rest if rel not in verbunden]",
" rest = list(rest)",
["GRUNDLINIE"]),
("Sicherung im Vault erlaubt",
" if sicherung_pfad == vault or vault in sicherung_pfad.parents:",
" if False:",
["anwenden | Sicherungsordner im Vault"]),
("fremde Aenderung vor dem Anhaengen nicht erkannt",
" if pfad.read_bytes() != alt:",
" if False:",
["anwenden | fremder Schreiber zwischen Lesen und Anhaengen bricht ab"]),
("GEAENDERT.txt unter anderem Namen",
r' (sicherung / "GEAENDERT.txt").write_text("\n".join(GESCHRIEBEN) + "\n", encoding="utf-8", newline="\n")',
r' (sicherung / "ANDERS.txt").write_text("\n".join(GESCHRIEBEN) + "\n", encoding="utf-8", newline="\n")',
["anwenden | schreibt genau die erwarteten Bytes"]),
("ungetrackte Ordner nur als Ordner",
' roh = git(Path(baum), "status", "--porcelain", "-z", "--untracked-files=all")',
' roh = git(Path(baum), "status", "--porcelain", "-z", "--untracked-files=normal")',
["git | ungetrackter Planordner zaehlt je Datei"]),
("ignorierte Dateien zaehlen als geaendert",
' roh = git(Path(baum), "status", "--porcelain", "-z", "--untracked-files=all")',
' roh = git(Path(baum), "status", "--porcelain", "-z", "--untracked-files=all", "--ignored")',
["git | Vault-Wurzel als Repo, ignorierte Dateien zaehlen nicht"]),
("Umbenennung als zwei Eintraege gelesen",
' if "R" in eintrag[:2] or "C" in eintrag[:2]:',
" if False:",
["git | Umbenennung: alter Pfad ist kein eigener Eintrag"]),
("git ohne GIT_OPTIONAL_LOCKS",
' umgebung["GIT_OPTIONAL_LOCKS"] = "0"',
" pass",
["git | jeder git-Aufruf mit GIT_OPTIONAL_LOCKS=0"]),
("Vault-Wurzel nicht als Repo geprueft",
" while ordner == vault or vault in ordner.parents:",
" while ordner != vault and vault in ordner.parents:",
["git | Vault-Wurzel als Repo, docs/ nicht ignoriert"]),
("docs/ an der Wurzel ohne Regel",
' if teile[0] == "docs" and len(teile) >= 2:',
" if False:",
["GRUNDLINIE"]),
("Wurzel-README nicht geprueft",
" if not existiert(vault, hub):",
" if False:",
["regel | Vault-Wurzel ohne README"]),
("Wurzel-Planordner ohne Uebersicht nicht erkannt",
" if not existiert(vault, kopf):",
" if False:",
["regel | Wurzel-Planordner ohne 00-uebersicht.md"]),
("Wurzel-Plandatei zu tief angehaengt",
' if teile[1] == "plans" and len(teile) > 4:',
" if False:",
["GRUNDLINIE"]),
("Datei direkt unter docs/ ohne Regel",
' if innen == ["CHANGELOG.md"] or (innen[:1] == ["docs"] and len(innen) >= 2):',
' if innen == ["CHANGELOG.md"] or (innen[:1] == ["docs"] and len(innen) >= 3):',
["GRUNDLINIE"]),
]
def streng_utf8(roh: bytes) -> str:
try:
return roh.decode("utf-8")
except UnicodeDecodeError as exc:
return f"UNGUELTIGES-UTF-8: {exc}"
def fahre(skript: Path, argumente: list) -> tuple:
start = time.perf_counter()
lauf = subprocess.run(
[sys.executable, str(skript), *argumente],
capture_output=True,
stdin=subprocess.DEVNULL,
timeout=300,
)
dauer = time.perf_counter() - start
return lauf.returncode, streng_utf8(lauf.stdout), lauf.stderr.decode("utf-8", errors="replace"), dauer
def lies_ausgabe(out: str) -> tuple:
ziele, rest, ueber = {}, {}, {}
aktuell = None
for zeile in out.replace("\r\n", "\n").split("\n"):
if zeile.startswith("ZIEL "):
aktuell = zeile[5:].split(" [", 1)[0]
ziele[aktuell] = []
elif zeile.startswith(" | ") and aktuell is not None:
ziele[aktuell].append(zeile[6:])
else:
aktuell = None
if zeile.startswith("REST "):
rel, _, grund = zeile[5:].partition(": ")
rest[rel] = grund
elif zeile.startswith("UEBERSPRUNGEN "):
rel, _, grund = zeile[14:].partition(": ")
ueber[rel] = grund
return ziele, rest, ueber
def bewerte(fall: Fall, code: int, out: str, v: Path, vorher: dict, sicherung: Path) -> list:
probleme = []
if code != fall.code:
probleme.append(f"Exit {code} statt {fall.code}")
ziele, rest, ueber = lies_ausgabe(out)
if fall.ziele is not None:
if sorted(ziele) != sorted(fall.ziele):
probleme.append(f"Ziele {sorted(ziele)} statt {sorted(fall.ziele)}")
for rel, zeilen in fall.ziele.items():
if rel in ziele and ziele[rel] != zeilen:
probleme.append(f"{rel}: Zeilen {ziele[rel]!r} statt {zeilen!r}")
for rel, zeilen in fall.ziel_zeilen.items():
if ziele.get(rel) != zeilen:
probleme.append(f"{rel}: Zeilen {ziele.get(rel)!r} statt {zeilen!r}")
for rel in fall.mit_ziel:
if rel not in ziele:
probleme.append(f"Ziel fehlt: {rel}")
for rel in fall.ohne_ziel:
if rel in ziele:
probleme.append(f"Ziel unerwartet: {rel}")
if fall.rest is not None and sorted(rest) != sorted(fall.rest):
probleme.append(f"Liste {sorted(rest)} statt {sorted(fall.rest)}")
for rel, teil in list((fall.rest or {}).items()) + list(fall.mit_rest.items()):
if rel not in rest:
probleme.append(f"nicht auf der Liste: {rel}")
elif teil not in rest[rel]:
probleme.append(f"Liste {rel}: {rest[rel]!r} ohne {teil!r}")
for rel, teil in fall.ueber.items():
if rel not in ueber:
probleme.append(f"nicht uebersprungen: {rel}")
elif teil not in ueber[rel]:
probleme.append(f"uebersprungen {rel}: {ueber[rel]!r} ohne {teil!r}")
for text in fall.texte:
if text not in out:
probleme.append(f"fehlt in der Ausgabe: {text}")
nachher = abbild(v)
geaendert = sorted(r for r in set(vorher) | set(nachher) if vorher.get(r) != nachher.get(r))
if fall.modus in ("anwenden", "zweimal"):
erwartet = sorted(fall.ziele or {})
if geaendert != erwartet:
probleme.append(f"geaendert {geaendert} statt {erwartet}")
liste = sicherung / "GEAENDERT.txt"
if not liste.is_file() or liste.read_bytes() != ("\n".join(erwartet) + "\n").encode("utf-8"):
probleme.append(f"GEAENDERT.txt fehlt oder nennt nicht genau {erwartet}")
for rel in erwartet:
kopie = sicherung / rel
if not kopie.is_file() or kopie.read_bytes() != vorher.get(rel):
probleme.append(f"Sicherung fehlt oder weicht ab: {rel}")
if rel in fall.nachher or rel not in nachher:
continue
ende = "\r\n" if b"\r\n" in vorher.get(rel, b"") else "\n"
schwanz = (ende.join(fall.ziele[rel]) + ende).encode("utf-8")
if not nachher[rel].startswith(vorher.get(rel, b"")) or not nachher[rel].endswith(schwanz):
probleme.append(f"{rel}: nicht genau alter Inhalt plus Anhang")
for rel, soll in fall.nachher.items():
if nachher.get(rel) != soll:
probleme.append(f"{rel}: {nachher.get(rel)!r} statt {soll!r}")
elif fall.modus == "anwenden_fremd":
erwartet = sorted(fall.nachher)
if geaendert != erwartet:
probleme.append(f"geaendert {geaendert} statt {erwartet}")
for rel, soll in fall.nachher.items():
if nachher.get(rel) != soll:
probleme.append(f"{rel}: {nachher.get(rel)!r} statt {soll!r}")
elif geaendert:
probleme.append(f"hat Dateien geaendert: {geaendert}")
if fall.modus == "anwenden_abbruch" and sicherung.exists():
probleme.append("Sicherungsordner trotz Abbruch angelegt")
return probleme
def lauf_fall(fall: Fall, basis: Path, arbeit: Path, skript: Path) -> tuple:
v = arbeit / "fall"
entferne(v)
for alt in arbeit.glob("sicherung*"):
entferne(alt)
shutil.copytree(basis, v)
fall.aendern(v)
vorher = abbild(v)
sicherung = arbeit / "sicherung"
argumente = ["--vault", str(v)]
if fall.modus in ("anwenden", "zweimal", "anwenden_abbruch", "anwenden_fremd"):
argumente += ["--anwenden", "--sicherung", str(sicherung)]
elif fall.modus == "ohne_sicherung":
argumente += ["--anwenden"]
elif fall.modus == "sicherung_da":
sicherung.mkdir()
argumente += ["--anwenden", "--sicherung", str(sicherung)]
elif fall.modus == "sicherung_im_vault":
argumente += ["--anwenden", "--sicherung", str(v / "Sicherung")]
ausfuehren = skript
if fall.huelle:
ausfuehren = arbeit / "huelle.py"
ausfuehren.write_bytes(HUELLE.encode("utf-8"))
argumente = [str(skript), fall.huelle] + argumente
code, out, err, dauer = fahre(ausfuehren, argumente)
probleme = bewerte(fall, code, out, v, vorher, sicherung)
if fall.modus == "zweimal" and not probleme:
erster = abbild(v)
code2, out2, err2, _ = fahre(skript, ["--vault", str(v), "--anwenden", "--sicherung",
str(arbeit / "sicherung-2")])
ziele2, _, _ = lies_ausgabe(out2)
if code2 != 0:
probleme.append(f"zweiter Lauf Exit {code2}")
if ziele2:
probleme.append(f"zweiter Lauf will anhaengen: {sorted(ziele2)}")
if abbild(v) != erster:
probleme.append("zweiter Lauf hat Dateien geaendert")
out, err = out + out2, err + err2
kopf = f"exit={code} {dauer:.2f}s"
if not probleme:
return True, kopf
text = kopf + "\n" + "\n".join(" " + p for p in probleme)
return False, text + f"\n stdout: {out[:2000]!r}\n stderr: {err[:800]!r}"
def fahre_liste(faelle: list, skript: Path, arbeit: Path, ausgabe: bool) -> dict:
basis = arbeit / "grundlinie"
if not basis.exists():
baue_grundlinie(basis)
ergebnis = {}
for fall in faelle:
try:
ok, text = lauf_fall(fall, basis, arbeit, skript)
except Exception as exc:
ok, text = False, f"ABSTURZ im Treiber: {type(exc).__name__}: {exc}"
ergebnis[fall.name] = ok
if ausgabe:
print(f"{'BESTANDEN' if ok else 'FEHLER':10} {fall.name} {text}")
if fall is GRUNDLINIE and not ok:
break
return ergebnis
def rotlauf() -> int:
quelle = BESTAND.read_text(encoding="utf-8")
nach_name = {f.name: f for f in ALLE}
alle_ok = True
for name, aus, wird, rot_bei in MUTANTEN:
anzahl = quelle.count(aus + "\n")
unbekannt = [n for n in rot_bei if n not in nach_name]
if anzahl != 1 or unbekannt:
print(f"MUSTER {name}: steht {anzahl}-mal in waisen_bestand.py, unbekannte Faelle {unbekannt}")
alle_ok = False
continue
arbeit = Path(tempfile.mkdtemp(prefix="bestand-rot-")).resolve()
try:
ordner = arbeit / "skript"
ordner.mkdir()
for begleiter in BEGLEITER:
shutil.copy2(begleiter, ordner / begleiter.name)
skript = ordner / BESTAND.name
with open(skript, "w", encoding="utf-8", newline="\n") as datei:
datei.write(quelle.replace(aus + "\n", wird + "\n"))
ergebnis = fahre_liste([nach_name[n] for n in rot_bei], skript, arbeit, ausgabe=False)
finally:
entferne(arbeit)
gruen = [n for n in rot_bei if ergebnis.get(n)]
if gruen:
alle_ok = False
print(f"UEBERLEBT {name}: gruen blieben {gruen}")
else:
print(f"GETOETET {name}")
if alle_ok:
print("Rotlauf: alle Mutanten getoetet.")
return 0
print("Rotlauf: mindestens ein Mutant nicht getoetet oder ein Muster falsch.")
return 1
def main() -> int:
for pfad in [BESTAND] + BEGLEITER:
if not pfad.is_file():
print(f"ABBRUCH: {pfad} fehlt")
return 2
if shutil.which("git") is None:
print("ABBRUCH: git fehlt im PATH, die Git-Faelle messen sonst nichts")
return 2
namen = [f.name for f in ALLE]
if len(set(namen)) != len(namen):
print("ABBRUCH: ein Fallname steht doppelt")
return 2
if "--rotlauf" in sys.argv[1:]:
return rotlauf()
arbeit = Path(tempfile.mkdtemp(prefix="bestand-faelle-")).resolve()
try:
ergebnis = fahre_liste(ALLE, BESTAND, arbeit, ausgabe=True)
if not ergebnis.get(GRUNDLINIE.name):
print("ABBRUCH: Die Grundlinie ist nicht gruen. Der Rest misst nichts.")
return 2
bestanden = sum(1 for ok in ergebnis.values() if ok)
print(f"\n{bestanden} von {len(ergebnis)} Faellen bestanden.")
return 0 if bestanden == len(ergebnis) else 1
finally:
entferne(arbeit)
if __name__ == "__main__":
try:
sys.stdout.reconfigure(encoding="utf-8")
except AttributeError:
pass
raise SystemExit(main())
````
## Schritt 2 — Rot zuerst
Ohne `waisen_bestand.py` muss der Treiber abbrechen. In einem einzigen Bash-Aufruf:
```
mv D:/Claude/.vault-tools/linkcheck/waisen_bestand.py D:/Claude/.vault-tools/linkcheck/waisen_bestand.py.weg; python D:/Claude/.vault-tools/linkcheck/faelle_waisen_bestand.py; echo "exit=$?"; mv D:/Claude/.vault-tools/linkcheck/waisen_bestand.py.weg D:/Claude/.vault-tools/linkcheck/waisen_bestand.py
```
Erwartet: `ABBRUCH: D:\Claude\.vault-tools\linkcheck\waisen_bestand.py fehlt` und `exit=2`. Danach liegt die Datei wieder an ihrem Platz.
## Schritt 3 — Angriffsliste
```
PYTHONIOENCODING=utf-8 python D:/Claude/.vault-tools/linkcheck/faelle_waisen_bestand.py; echo "exit=$?"
```
Erwartet: erste Zeile `BESTANDEN GRUNDLINIE`, keine Zeile, die mit `FEHLER` beginnt, Schlusszeile `N von N Faellen bestanden.` mit zweimal derselben Zahl, `exit=0`. Der Lauf legt Git-Repos im Temp-Ordner an und dauert deshalb länger als der Treiber aus Task 01. Meldet der Fall `git | Umbenennung: alter Pfad ist kein eigener Eintrag` die Zeile `ABSTURZ im Treiber: RuntimeError: git meldet keine Umbenennung`, erkennt das installierte git die Umbenennung nicht: nichts anpassen, melden.
## Schritt 4 — Rotlauf
```
PYTHONIOENCODING=utf-8 python D:/Claude/.vault-tools/linkcheck/faelle_waisen_bestand.py --rotlauf; echo "exit=$?"
```
Erwartet: je Mutant eine Zeile `GETOETET`, keine Zeile `UEBERLEBT` oder `MUSTER`, Schlusszeile `Rotlauf: alle Mutanten getoetet.`, `exit=0`.
## Schritt 5 — Zähler unverändert grün
```
PYTHONIOENCODING=utf-8 python D:/Claude/.vault-tools/linkcheck/faelle_waisen.py; echo "exit=$?"
```
Erwartet: `exit=0`.
## Bericht
Melde die vollständige Ausgabe von Schritt 1, 2, 4 und 5, von Schritt 3 die Schlusszeile und jede Zeile, die nicht mit `BESTANDEN` beginnt. Läuft etwas anders als erwartet: nichts anpassen, melden.
Reference in new issue View Git Blame Copy Permalink