feat: unload ux opti, profile default prompt removed, better ux tag on dataset panel

Author: Specthram

server/routers/profiles.py

@@ -12,7 +12,12 @@
 
 from server.jobs import manager
 from server.runners import model as model_runner
-from server.schemas import ProfileBody, ProfileDetectBody, ProfileSelectBody
+from server.schemas import (
+    ProfileBody,
+    ProfileDetectBody,
+    ProfilePromptBody,
+    ProfileSelectBody,
+)
 from src import fs_browse, model_profiles
 from src.settings import get_model_dir
 
@@ -56,6 +61,14 @@ def select_profile(body: ProfileSelectBody) -> dict:
     return {"ok": True}
 
 
+@router.post("/{profile_id}/prompt")
+def remember_prompt(profile_id: int, body: ProfilePromptBody) -> dict:
+    """Remember the prompt preset last used with a profile."""
+    if not model_profiles.set_last_prompt(profile_id, body.title):
+        raise HTTPException(status_code=404, detail="profile not found")
+    return {"ok": True}
+
+
 @router.post("/detect")
 def detect(body: ProfileDetectBody) -> dict:
     """Re-run type / mmproj auto-detection for a picked weights file."""
@@ -68,6 +81,22 @@ def detect(body: ProfileDetectBody) -> dict:
     }
 
 
+@router.get("/detect-hf")
+def detect_hf(repo: str = "") -> dict:
+    """Guess the family / format / name for a Hugging Face repo id.
+
+    ``type`` is auto-detected from the repo tail (empty → the editor shows a
+    "from repo config" badge, resolved from the config at load); ``format`` is
+    guessed from the repo name; ``name`` is the repo tail.
+    """
+    repo = repo.strip()
+    return {
+        "type": model_profiles.detect_repo_type(repo) if repo else "",
+        "format": "gguf" if "gguf" in repo.lower() else "safetensors",
+        "name": repo.rsplit("/", 1)[-1] if repo else "",
+    }
+
+
 @router.put("/{profile_id}")
 def update_profile(profile_id: int, body: ProfileBody) -> dict:
     """Apply the provided fields to an existing profile."""
@@ -101,10 +130,20 @@ def load_profile(profile_id: int) -> dict:
         raise HTTPException(
             status_code=409, detail="profile has no weights file"
         )
+    # An HF profile whose repo is not yet cached downloads on first load: name
+    # the job so the drawer reads "Download <repo>" with a byte progress bar.
+    downloads = profile.get(
+        "source"
+    ) == "hf" and not model_profiles.is_repo_cached(profile.get("repo") or "")
+    name = (
+        f"Download {profile['repo']}"
+        if downloads
+        else f"Load {profile['name']}"
+    )
     job = manager.submit(
         "load-model",
-        f"Load {profile['name']}",
+        name,
         model_runner.load_profile_body(cfg, profile),
-        sub="loading",
+        sub="downloading" if downloads else "loading",
     )
     return {"job_id": job.id}

server/runners/model.py

@@ -28,7 +28,13 @@ def run(progress: Progress) -> dict:
             for status, _loaded in loader.unload_model():
                 progress(sub=status)
             model_profiles.set_loaded_id(None)
-        for status, _loaded in loader.load_model(model_cfg):
+
+        def on_bytes(done: int, total: int, label: str) -> None:
+            # Stream Hugging Face download progress as the job's byte counter;
+            # progress() raises JobStopped when the user cancels the download.
+            progress(done=done, total=total, sub=label)
+
+        for status, _loaded in loader.load_model(model_cfg, on_bytes=on_bytes):
             progress(sub=status)
         if loader.is_model_loaded():
             model_profiles.set_loaded_id(profile["id"])

server/schemas.py

@@ -26,6 +26,8 @@ class ProfileBody(BaseModel):
     """
 
     name: str | None = None
+    source: str | None = None  # "local" | "hf"
+    repo: str | None = None  # HF hub repo id (source == "hf")
     file: str | None = None
     dir: str | None = None
     format: str | None = None
@@ -49,6 +51,12 @@ class ProfileSelectBody(BaseModel):
     id: int
 
 
+class ProfilePromptBody(BaseModel):
+    """Body remembering the prompt preset last used with a profile."""
+
+    title: str
+
+
 class ProfileDetectBody(BaseModel):
     """Body for re-running type/mmproj auto-detection on a picked file."""
 

src/caption_judge.py

@@ -125,69 +125,133 @@ def _edits(base_tokens: list, side_tokens: list) -> list:
     ]
 
 
-def apply_fix(base: str, current: str, incoming: str) -> str:
-    """Apply the ``base → incoming`` correction on top of ``current``.
-
-    Three-way word merge, so accepting one finding after another keeps the
-    earlier accept instead of resurrecting the run-time caption: regions the
-    fix rewrites take the fix's words, regions only ``current`` changed keep
-    the current words, and when both touched the same region the fix — the
-    one the user just accepted — wins.
+# A base segment ends on a word carrying sentence/clause punctuation, so a
+# conflict resolves over a whole sentence (prose) or a whole tag (booru).
+_SEGMENT_END = re.compile(r"[.!?;,]$")
+
+
+def _segment_bounds(tokens: list) -> list:
+    """Return the base's segments as token ranges (sentences / clauses)."""
+    bounds, start = [], 0
+    for index, token in enumerate(tokens):
+        if not token.isspace() and _SEGMENT_END.search(token):
+            end = index + 1
+            if end < len(tokens) and tokens[end].isspace():
+                end += 1
+            bounds.append((start, end))
+            start = end
+    if start < len(tokens) or not bounds:
+        bounds.append((start, len(tokens)))
+    return bounds
+
+
+def _overlaps(first: tuple, second: tuple) -> bool:
+    """Whether two base-coordinate edits collide (insertions zero-width)."""
+    a1, a2, _ = first
+    b1, b2, _ = second
+    if a1 == a2 and b1 == b2:  # two insertions at the same point collide
+        return a1 == b1
+    return a1 < b2 and b1 < a2
+
+
+def _replay(tokens: list, start: int, end: int, edits: list) -> list:
+    """Return ``tokens[start:end]`` with the (contained) edits applied."""
+    output = []
+    position = start
+    for span_start, span_end, replacement in sorted(
+        edits, key=lambda edit: (edit[0], edit[1])
+    ):
+        output.extend(tokens[position:span_start])
+        output.extend(replacement)
+        position = span_end
+    output.extend(tokens[position:end])
+    return output
+
+
+def resolve_fix(base: str, current: str, incoming: str) -> dict:
+    """Resolve the ``base → incoming`` fix against the live ``current``.
+
+    Git-style three-way merge that never re-locates a diff: both sides'
+    edits stay in the coordinates of the ``base`` they were computed
+    against, so collision detection is exact interval arithmetic — no fuzzy
+    matching, hence no false anchor when a sentence changed.
+
+    Edits that do not collide merge automatically, wherever they sit. When
+    the two sides collide, the *whole segment* (sentence / clause) around
+    the collision takes the incoming fix's rendering verbatim — one
+    coherent, judge-authored sentence, never an interleaving of two
+    rewrites — and the result is flagged so the UI shows a ⚠ conflict the
+    user settles with accept / reject / inline edit.
+
+    Returns ``{"text": str, "conflict": bool}``.
     """
     if base == incoming:  # no-op fix — never clobber the live caption
-        return current
+        return {"text": current, "conflict": False}
     if current in (base, incoming):
-        return incoming
+        return {"text": incoming, "conflict": False}
     tokens = _tokens(base)
     ours = _edits(tokens, _tokens(current))
     theirs = _edits(tokens, _tokens(incoming))
 
-    merged = []
-    cursor = 0  # position in base tokens
-    oi = ti = 0
-    while oi < len(ours) or ti < len(theirs):
-        # Open the next cluster at the earliest remaining edit, then absorb
-        # every span (either side) that overlaps or touches it.
-        start = min(
-            edits[index][0]
-            for edits, index in ((ours, oi), (theirs, ti))
-            if index < len(edits)
+    # Group the base's segments so every edit falls entirely inside one
+    # group (an edit spanning a boundary fuses the neighbours).
+    groups = _segment_bounds(tokens)
+    for start, end, _ in ours + theirs:
+        end = max(end, min(start + 1, len(tokens)))
+        touched = [g for g in groups if g[0] < end and start < g[1]] or [
+            groups[-1]
+        ]
+        fused = (
+            min(g[0] for g in touched),
+            max(g[1] for g in touched),
         )
-        end = start
-        cluster_ours, cluster_theirs = [], []
+        groups = [g for g in groups if g not in touched]
+        groups.append(fused)
+        groups.sort()
 
-        def touches(span_start, cluster_end):
-            """Overlap, or separated from the cluster by whitespace only."""
-            return span_start <= cluster_end or all(
-                token.isspace() for token in tokens[cluster_end:span_start]
+    merged = []
+    conflict = False
+    for index, (group_start, group_end) in enumerate(groups):
+        last = index == len(groups) - 1
+        inside_ours = [
+            e for e in ours if _inside(e, group_start, group_end, last)
+        ]
+        inside_theirs = [
+            e for e in theirs if _inside(e, group_start, group_end, last)
+        ]
+        collides = any(
+            _overlaps(first, second)
+            for first in inside_ours
+            for second in inside_theirs
+        )
+        if collides:
+            # The judge's whole sentence, verbatim; our edits there drop.
+            conflict = True
+            merged.extend(
+                _replay(tokens, group_start, group_end, inside_theirs)
+            )
+        else:
+            merged.extend(
+                _replay(
+                    tokens,
+                    group_start,
+                    group_end,
+                    inside_ours + inside_theirs,
+                )
             )
+    return {"text": "".join(merged), "conflict": conflict}
 
-        grew = True
-        while grew:
-            grew = False
-            while oi < len(ours) and touches(ours[oi][0], end):
-                cluster_ours.append(ours[oi])
-                end = max(end, ours[oi][1])
-                oi += 1
-                grew = True
-            while ti < len(theirs) and touches(theirs[ti][0], end):
-                cluster_theirs.append(theirs[ti])
-                end = max(end, theirs[ti][1])
-                ti += 1
-                grew = True
-        merged.extend(tokens[cursor:start])
-        # Conflicting cluster → the incoming fix wins; otherwise replay the
-        # only side that touched it.
-        winner = cluster_theirs if cluster_theirs else cluster_ours
-        position = start
-        for span_start, span_end, replacement in winner:
-            merged.extend(tokens[position:span_start])
-            merged.extend(replacement)
-            position = span_end
-        merged.extend(tokens[position:end])
-        cursor = end
-    merged.extend(tokens[cursor:])
-    return "".join(merged)
+
+def _inside(edit: tuple, start: int, end: int, last: bool) -> bool:
+    """Whether an edit falls inside ``[start, end)`` (inserts included).
+
+    An insertion belongs to the group containing its point; one sitting at
+    the very end of the text belongs to the last group.
+    """
+    e1, e2, _ = edit
+    if e1 == e2:
+        return start <= e1 < end or (last and e1 == end)
+    return start <= e1 and e2 <= end
 
 
 def judged_finding(before: str, verdict: dict | None) -> dict | None:

src/db.py

@@ -436,6 +436,10 @@
     status TEXT NOT NULL DEFAULT 'pending'
         CHECK (status IN ('pending', 'accepted', 'rejected')),
     applied_caption TEXT,
+    -- The live caption at accept time, so an undo restores exactly the text
+    -- the accept replaced (never the run-time original, which other accepts
+    -- may have already moved past).
+    undo_caption TEXT,
     created_at TEXT NOT NULL DEFAULT (datetime('now')),
     decided_at TEXT
 );
@@ -878,6 +882,11 @@ def ensure_database(db_path=None):
                 ("query", "query TEXT"),
             ):
                 _ensure_column(conn, "watermark_zone", column, definition)
+            # Undo snapshot for review accepts (see review_queue): databases
+            # created before conflict-aware accepts lack the column.
+            _ensure_column(
+                conn, "review_finding", "undo_caption", "undo_caption TEXT"
+            )
             # v2 retired the per-zone "review" status: any pre-v2 zone still
             # carrying it becomes a plain detected zone (idempotent).
             conn.execute(