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.4.0
+Version: 1.5.1
 Datum: 2025-09-09
 
 Kurzbeschreibung
@@ -12,18 +12,36 @@ 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).
 
+Wichtig
+-------
+- **Nur Inhalte** gehen in den Hash: Weder Dateisystem-Zeitstempel (mtime/ctime)
+  noch sonstige FS-Metadaten werden berücksichtigt.
+- Hash-Quelle: Parser-Body (Default) oder Rohdatei-Body (Frontmatter via Regex entfernt).
+
+Änderungen in v1.5.1
+--------------------
+- Neue Env-Var **MINDNET_HASH_COMPARE** als Synonym zu MINDNET_HASH_MODE.
+- Akzeptiert komfortable Werte (case-insensitive): **Body**, **Frontmatter**, **Full**.
+  *Full* wird intern zu ``body+frontmatter`` normalisiert.
+- CLI akzeptiert weiterhin ``--hash-mode``; Importer reicht diese Einstellung durch.
+
 Hash-Steuerung
 --------------
-- Modus:  ``body`` (Default) | ``frontmatter`` | ``body+frontmatter``
+- Modus (welche Teile in den Hash einfließen):
-  * per Funktionsparameter ``hash_mode`` (prio 1)
+    * ``body`` (Default)
-  * oder ENV ``MINDNET_HASH_MODE`` (prio 2)
+    * ``frontmatter``
-- Normalisierung: ``canonical`` (Default) | ``none``
+    * ``body+frontmatter``  (Synonym CLI/ENV: ``full``)
-  * per Funktionsparameter ``hash_normalize`` (prio 1)
+  Quelle:
-  * oder ENV ``MINDNET_HASH_NORMALIZE`` (prio 2)
+    * Funktionsparameter ``hash_mode`` (höchste Priorität)
+    * Env ``MINDNET_HASH_MODE`` oder **``MINDNET_HASH_COMPARE``** (Fallback)
+  Normalisierung:
+    * ``canonical`` (Default) | ``none`` — via Param ``hash_normalize`` oder Env ``MINDNET_HASH_NORMALIZE``
+  Quelle des Body-Textes:
+    * ``parsed`` (Default) | ``raw`` — via Param ``hash_source`` oder Env ``MINDNET_HASH_SOURCE``
 
-Beispiele (CLI – Sichtprüfung)
+CLI (Sichtprüfung)
-------------------------------
+------------------
-    python3 -m app.core.note_payload --from-file ./vault/demo.md --vault-root ./vault --print
+    python3 -m app.core.note_payload --from-file ./vault/demo.md --vault-root ./vault --print --hash-source raw
 """
 
 from __future__ import annotations
@@ -31,16 +49,16 @@ import argparse
 import hashlib
 import json
 import os
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Tuple
 
 try:
-    from app.core.parser import read_markdown, extract_wikilinks
+    from app.core.parser import read_markdown, extract_wikilinks, FRONTMATTER_RE
 except Exception:  # pragma: no cover
-    from .parser import read_markdown, extract_wikilinks  # type: ignore
+    from .parser import read_markdown, extract_wikilinks, FRONTMATTER_RE  # type: ignore
 
 
 # ---------------------------------------------------------------------------
-# Hashing
+# Helpers
 # ---------------------------------------------------------------------------
 
 def _canon_frontmatter(fm: Dict[str, Any]) -> str:
@@ -51,13 +69,62 @@ 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
+    # canonical: \r\n→\n, trailing spaces entfernen
     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 _resolve_hash_mode(explicit: Optional[str]) -> str:
+    """
+    Normalisiert den Hash-Modus auf einen der Werte:
+    'body' | 'frontmatter' | 'body+frontmatter'
+    Akzeptiert auch 'full' als Alias für 'body+frontmatter'.
+    Beachtet zusätzlich die Env-Variablen MINDNET_HASH_MODE und MINDNET_HASH_COMPARE.
+    """
+    if explicit:
+        val = explicit.strip().lower()
+    else:
+        val = (os.environ.get("MINDNET_HASH_MODE") or os.environ.get("MINDNET_HASH_COMPARE") or "body").strip().lower()
+    if val in ("full", "fulltext", "body+frontmatter", "bodyplusfrontmatter"):
+        return "body+frontmatter"
+    if val in ("frontmatter", "fm"):
+        return "frontmatter"
+    # default & fallbacks
+    return "body"
+
+def _read_raw_body_from_file(file_path: Optional[str]) -> Tuple[str, Dict[str, Any]]:
+    """Liest die Rohdatei und extrahiert Body & Frontmatter ohne Parser-Logik.
+
+    Rückgabe:
+        (body_text, frontmatter_dict)
+    """
+    if not file_path or not os.path.exists(file_path):
+        return "", {}
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            raw = f.read()
+    except Exception:
+        return "", {}
+    # Frontmatter per Regex entfernen
+    m = FRONTMATTER_RE.match(raw)
+    fm = {}
+    if m:
+        fm_txt = m.group(1)
+        try:
+            import yaml  # lazy
+            fm = yaml.safe_load(fm_txt) or {}
+        except Exception:
+            fm = {}
+        body = raw[m.end():]
+    else:
+        body = raw
+    return body, fm
+
+
+# ---------------------------------------------------------------------------
+# Hashing
+# ---------------------------------------------------------------------------
+
 def compute_hash(
     *,
     body: Optional[str],
@@ -76,7 +143,7 @@ def compute_hash(
         - "canonical" (Default)
         - "none"
     """
-    mode = (mode or os.environ.get("MINDNET_HASH_MODE", "body")).strip().lower()
+    mode = _resolve_hash_mode(mode)
     normalize = (normalize or os.environ.get("MINDNET_HASH_NORMALIZE", "canonical")).strip().lower()
 
     body = _normalize_body(body or "", normalize)
@@ -104,6 +171,8 @@ def make_note_payload(
     *,
     hash_mode: Optional[str] = None,
     hash_normalize: Optional[str] = None,
+    hash_source: Optional[str] = None,
+    file_path: Optional[str] = None,
 ) -> Dict[str, Any]:
     """
     Erzeugt den Payload für eine geparste Note.
@@ -115,9 +184,13 @@ def make_note_payload(
     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).
+        "body" | "frontmatter" | "body+frontmatter" | "full" (Alias; überschreibt ENV).
     hash_normalize : Optional[str]
         "canonical" | "none" (überschreibt ENV).
+    hash_source : Optional[str]
+        "parsed" (Default) oder "raw". Wenn "raw", wird der Body aus der Rohdatei gelesen.
+    file_path : Optional[str]
+        Pfad zur Markdown-Datei, erforderlich für ``hash_source=raw``.
 
     Returns
     -------
@@ -125,17 +198,30 @@ def make_note_payload(
         Qdrant-Payload für die Notes-Collection.
     """
     # "Duck typing": dict oder Objekt akzeptieren
-    fm = (
+    if isinstance(parsed, dict):
-        getattr(parsed, "frontmatter", None)
+        fm = parsed.get("frontmatter") or {}
-        or getattr(parsed, "fm", None)
+        body = parsed.get("body") or ""
-        or getattr(parsed, "front_matter", None)
+        path = parsed.get("path") or ""
-        or (parsed.get("frontmatter") if isinstance(parsed, dict) else {})
+    else:
-    ) or {}
+        fm = getattr(parsed, "frontmatter", {}) or {}
-    body = getattr(parsed, "body", None) or (parsed.get("body") if isinstance(parsed, dict) else "") or ""
+        body = getattr(parsed, "body", "") or ""
-    path = getattr(parsed, "path", None) or (parsed.get("path") if isinstance(parsed, dict) else "") or ""
+        path = getattr(parsed, "path", "") or ""
 
-    # Hash gem. Modus bilden
+    # Hash-Quelle bestimmen
-    hash_fulltext = compute_hash(body=body, frontmatter=fm, mode=hash_mode, normalize=hash_normalize)
+    src = (hash_source or os.environ.get("MINDNET_HASH_SOURCE", "parsed")).strip().lower()
+    raw_body, raw_fm = ("", {})
+    if src == "raw":
+        raw_body, raw_fm = _read_raw_body_from_file(file_path or path)
+        # Roh-FM ergänzen (nicht überschreiben)
+        if isinstance(raw_fm, dict) and raw_fm:
+            merged_fm = dict(fm)
+            for k, v in raw_fm.items():
+                merged_fm.setdefault(k, v)
+            fm = merged_fm
+
+    # Hash gemäß Modus/Quelle bilden
+    body_for_hash = raw_body if src == "raw" else body
+    hash_fulltext = compute_hash(body=body_for_hash, frontmatter=fm, mode=hash_mode, normalize=hash_normalize)
 
     # Pfad relativieren
     rel_path = path
@@ -145,9 +231,9 @@ def make_note_payload(
             rel = rel.replace("\\", "/").lstrip("/")  # normalisieren
             rel_path = rel
     except Exception:
-        pass  # Pfad nicht kritisch für Hash/ID
+        pass  # Pfad ist nicht kritisch für Hash/ID
 
-    # Optionale Note-Level-Wikilinks (Fallback, wenn Chunks nicht geliefert werden)
+    # Note-Level-Wikilinks (Fallback, wenn Chunks nicht geliefert werden)
     note_level_refs = list(dict.fromkeys(extract_wikilinks(body))) if body else []
 
     payload: Dict[str, Any] = {
@@ -160,16 +246,23 @@ def make_note_payload(
         "path": rel_path or fm.get("path"),
         "tags": fm.get("tags"),
         "hash_fulltext": hash_fulltext,
-        # Volltext persistieren (verlustfreie Rekonstruktion)
+        # Volltext persistieren (verlustfreie Rekonstruktion) – aus PARSED-Body
         "fulltext": body,
         # Fallback-Refs auf Note-Ebene
         "references": note_level_refs,
     }
 
-    for k in ("area", "project", "source", "lang", "slug"):
+    for k in ("area", "project", "source", "lang", "slug", "aliases"):
         if k in fm:
             payload[k] = fm[k]
 
+    # Optional: Roh-Body-Hash zusätzlich persistieren
+    if os.environ.get("MINDNET_HASH_STORE_RAW", "false").strip().lower() == "true" and src == "raw":
+        try:
+            payload["hash_raw_body"] = compute_hash(body=raw_body, frontmatter=fm, mode="body", normalize="none")
+        except Exception:
+            pass
+
     return payload
 
 
@@ -182,13 +275,15 @@ 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-mode", choices=["body", "frontmatter", "body+frontmatter", "full"], default=None)
     ap.add_argument("--hash-normalize", choices=["canonical", "none"], default=None)
+    ap.add_argument("--hash-source", choices=["parsed", "raw"], default=None)
     args = ap.parse_args()
 
     parsed = read_markdown(args.src)
     payload = make_note_payload(parsed, vault_root=args.vault_root,
-                                hash_mode=args.hash_mode, hash_normalize=args.hash_normalize)
+                                hash_mode=args.hash_mode, hash_normalize=args.hash_normalize,
+                                hash_source=args.hash_source, file_path=args.src)
 
     if args.do_print:
         print(json.dumps(payload, ensure_ascii=False, indent=2))