app/core/note_payload.py aktualisiert

app/core/note_payload.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 """
 Modul: app/core/note_payload.py
-Version: 1.3.1
+Version: 1.4.0
 Datum: 2025-09-09
 
 Kurzbeschreibung
@@ -12,15 +12,14 @@ Idempotenz wird der vollständige Body unter ``fulltext`` persistiert und
 der Dateipfad relativ zum Vault gespeichert. Das erlaubt eine verlustfreie
 Rekonstruktion im Export (erst ``fulltext``, sonst Chunks).
 
-Wesentliche Features
---------------------
-- Hash-Strategie via ENV ``MINDNET_HASH_MODE``:
-    * ``body`` (Default)
-    * ``frontmatter``
-    * ``body+frontmatter``
-- Persistenter Volltext im Note-Payload: ``fulltext``
-- Pfad-Relativierung (``path``) gegen ``vault_root``
-- Optionale Note-Level-Wikilinks (Fallback-Refs)
+Hash-Steuerung
+--------------
+- Modus:  ``body`` (Default) | ``frontmatter`` | ``body+frontmatter``
+  * per Funktionsparameter ``hash_mode`` (prio 1)
+  * oder ENV ``MINDNET_HASH_MODE`` (prio 2)
+- Normalisierung: ``canonical`` (Default) | ``none``
+  * per Funktionsparameter ``hash_normalize`` (prio 1)
+  * oder ENV ``MINDNET_HASH_NORMALIZE`` (prio 2)
 
 Beispiele (CLI – Sichtprüfung)
 ------------------------------
@@ -35,7 +34,6 @@ import os
 from typing import Any, Dict, Optional
 
 try:
-    # In deinem Parser heißen die Funktionen read_markdown / extract_wikilinks
     from app.core.parser import read_markdown, extract_wikilinks
 except Exception:  # pragma: no cover
     from .parser import read_markdown, extract_wikilinks  # type: ignore
@@ -49,18 +47,39 @@ def _canon_frontmatter(fm: Dict[str, Any]) -> str:
     """Kanonische, stabile JSON-Serialisierung der Frontmatter für Hashbildung."""
     return json.dumps(fm or {}, ensure_ascii=False, separators=(",", ":"), sort_keys=True)
 
+def _normalize_body(body: str, mode: str) -> str:
+    """Normalisiert den Body für reproduzierbare Hashes (oder nicht)."""
+    if mode == "none":
+        return body if body is not None else ""
+    # canonical: \r\n→\n, trailing spaces, mehrfach-blankzeilen trimmen
+    text = (body or "").replace("\r\n", "\n").replace("\r", "\n")
+    # trailing whitespace am Zeilenende entfernen
+    text = "\n".join(line.rstrip() for line in text.split("\n"))
+    # keine aggressivere Logik (keine inhaltliche Änderung)
+    return text
 
-def compute_hash(*, body: Optional[str], frontmatter: Optional[Dict[str, Any]], mode: Optional[str] = None) -> str:
+def compute_hash(
+    *,
+    body: Optional[str],
+    frontmatter: Optional[Dict[str, Any]],
+    mode: Optional[str] = None,
+    normalize: Optional[str] = None,
+) -> str:
     """
-    Berechnet einen Hex-Hash gemäß ``mode``.
+    Berechnet einen Hex-Hash gemäß ``mode`` und ``normalize``.
 
     mode:
         - "body" (Default)
         - "frontmatter"
         - "body+frontmatter"
+    normalize:
+        - "canonical" (Default)
+        - "none"
     """
     mode = (mode or os.environ.get("MINDNET_HASH_MODE", "body")).strip().lower()
-    body = body or ""
+    normalize = (normalize or os.environ.get("MINDNET_HASH_NORMALIZE", "canonical")).strip().lower()
+
+    body = _normalize_body(body or "", normalize)
     fm_s = _canon_frontmatter(frontmatter or {})
 
     h = hashlib.sha256()
@@ -79,7 +98,13 @@ def compute_hash(*, body: Optional[str], frontmatter: Optional[Dict[str, Any]],
 # Kernfunktion
 # ---------------------------------------------------------------------------
 
-def make_note_payload(parsed: Any, vault_root: Optional[str] = None) -> Dict[str, Any]:
+def make_note_payload(
+    parsed: Any,
+    vault_root: Optional[str] = None,
+    *,
+    hash_mode: Optional[str] = None,
+    hash_normalize: Optional[str] = None,
+) -> Dict[str, Any]:
     """
     Erzeugt den Payload für eine geparste Note.
 
@@ -89,6 +114,10 @@ def make_note_payload(parsed: Any, vault_root: Optional[str] = None) -> Dict[str
         Objekt mit Attributen/Keys ``frontmatter``, ``body``, ``path``.
     vault_root : Optional[str]
         Vault-Wurzel (für Pfad-Relativierung). Wenn ``None``, wird ``path`` unverändert übernommen.
+    hash_mode : Optional[str]
+        "body" | "frontmatter" | "body+frontmatter" (überschreibt ENV).
+    hash_normalize : Optional[str]
+        "canonical" | "none" (überschreibt ENV).
 
     Returns
     -------
@@ -105,8 +134,8 @@ def make_note_payload(parsed: Any, vault_root: Optional[str] = None) -> Dict[str
     body = getattr(parsed, "body", None) or (parsed.get("body") if isinstance(parsed, dict) else "") or ""
     path = getattr(parsed, "path", None) or (parsed.get("path") if isinstance(parsed, dict) else "") or ""
 
-    # Hash gem. Modus bilden (Default: body)
-    hash_fulltext = compute_hash(body=body, frontmatter=fm, mode=None)
+    # Hash gem. Modus bilden
+    hash_fulltext = compute_hash(body=body, frontmatter=fm, mode=hash_mode, normalize=hash_normalize)
 
     # Pfad relativieren
     rel_path = path
@@ -116,8 +145,7 @@ def make_note_payload(parsed: Any, vault_root: Optional[str] = None) -> Dict[str
             rel = rel.replace("\\", "/").lstrip("/")  # normalisieren
             rel_path = rel
     except Exception:
-        # fail-safe, Pfad ist nicht kritisch für Hash/ID
-        pass
+        pass  # Pfad nicht kritisch für Hash/ID
 
     # Optionale Note-Level-Wikilinks (Fallback, wenn Chunks nicht geliefert werden)
     note_level_refs = list(dict.fromkeys(extract_wikilinks(body))) if body else []
@@ -132,13 +160,12 @@ def make_note_payload(parsed: Any, vault_root: Optional[str] = None) -> Dict[str
         "path": rel_path or fm.get("path"),
         "tags": fm.get("tags"),
         "hash_fulltext": hash_fulltext,
-        # --- WICHTIG: Volltext persistieren ---
+        # Volltext persistieren (verlustfreie Rekonstruktion)
         "fulltext": body,
-        # --- Optionaler Fallback für Edge-Ableitung ---
+        # Fallback-Refs auf Note-Ebene
         "references": note_level_refs,
     }
 
-    # Bekannte optionale Frontmatter-Felder durchreichen
     for k in ("area", "project", "source", "lang", "slug"):
         if k in fm:
             payload[k] = fm[k]
@@ -155,10 +182,13 @@ def _cli() -> None:
     ap.add_argument("--from-file", dest="src", required=True, help="Pfad zur Markdown-Datei")
     ap.add_argument("--vault-root", dest="vault_root", default=None, help="Vault-Wurzel zur Pfad-Relativierung")
     ap.add_argument("--print", dest="do_print", action="store_true", help="Payload auf stdout ausgeben")
+    ap.add_argument("--hash-mode", choices=["body", "frontmatter", "body+frontmatter"], default=None)
+    ap.add_argument("--hash-normalize", choices=["canonical", "none"], default=None)
     args = ap.parse_args()
 
     parsed = read_markdown(args.src)
-    payload = make_note_payload(parsed, vault_root=args.vault_root)
+    payload = make_note_payload(parsed, vault_root=args.vault_root,
+                                hash_mode=args.hash_mode, hash_normalize=args.hash_normalize)
 
     if args.do_print:
         print(json.dumps(payload, ensure_ascii=False, indent=2))